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

notionary/database/database_provider.py

@@ -1,227 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Optional
-
-from notionary.database.client import NotionDatabaseClient
-from notionary.database.exceptions import DatabaseNotFoundException
-from notionary.database.models import NotionDatabaseResponse
-from notionary.util import LoggingMixin, SingletonMetaClass, format_uuid
-from notionary.util.fuzzy import find_best_match
-
-if TYPE_CHECKING:
-    from notionary import NotionDatabase
-
-
-class NotionDatabaseProvider(LoggingMixin, metaclass=SingletonMetaClass):
-    """
-    Provider class for creating and caching Notion database instances.
-
-    Prevents duplicate database creation when working with multiple pages from the same database.
-    Each Notion page references its parent database to determine selectable properties and options.
-    By caching database instances, this provider avoids excessive network requests when reading options,
-    significantly improving performance for repeated property lookups across many pages.
-    """
-
-    def __init__(self):
-        self._database_cache: dict[str, NotionDatabase] = {}
-
-    async def get_database_by_id(
-        self, database_id: str, token: Optional[str] = None, force_refresh: bool = False
-    ) -> NotionDatabase:
-        """Get a NotionDatabase by ID with caching."""
-        cache_key = self._create_id_cache_key(database_id)
-
-        if self._should_use_cache(cache_key, force_refresh):
-            self.logger.debug(f"Using cached database for ID: {database_id}")
-            return self._database_cache[cache_key]
-
-        database = await self._create_from_database_id(database_id, token)
-        self._cache_database(database, token)
-        return database
-
-    async def get_database_by_name(
-        self,
-        database_name: str,
-        token: Optional[str] = None,
-        min_similarity: float = 0.6,
-        force_refresh: bool = False,
-    ) -> NotionDatabase:
-        """Get a NotionDatabase by name with caching."""
-        name_cache_key = self._create_name_cache_key(database_name, token)
-
-        if self._should_use_cache(name_cache_key, force_refresh):
-            return self._database_cache[name_cache_key]
-
-        database = await self._create_from_database_name(
-            database_name, token, min_similarity
-        )
-
-        id_cache_key = self._create_id_cache_key(database.id)
-        if not force_refresh and id_cache_key in self._database_cache:
-            self.logger.debug(f"Found existing cached database by ID: {database.id}")
-            existing_database = self._database_cache[id_cache_key]
-
-            self._database_cache[name_cache_key] = existing_database
-            return existing_database
-
-        self._cache_database(database, token, database_name)
-        self.logger.debug(f"Cached database: {database.title} (ID: {database.id})")
-
-        return database
-
-    def invalidate_database_cache(self, database_id: str) -> bool:
-        """
-        Simply invalidate (remove) cache entries for a database without reloading.
-
-        Args:
-            database_id: The database ID to invalidate
-
-        Returns:
-            True if cache entries were found and removed, False otherwise
-        """
-
-        id_cache_key = self._create_id_cache_key(database_id)
-        was_cached = id_cache_key in self._database_cache
-
-        if not was_cached:
-            self.logger.debug(f"No cache entry found for database ID: {database_id}")
-            return False
-
-        removed_database = self._database_cache.pop(id_cache_key)
-        self.logger.debug(f"Invalidated cached database: {removed_database.title}")
-
-        name_keys_to_remove = [
-            cache_key
-            for cache_key, cached_db in self._database_cache.items()
-            if (cache_key.startswith("name:") and cached_db.id == database_id)
-        ]
-
-        for name_key in name_keys_to_remove:
-            self._database_cache.pop(name_key)
-            self.logger.debug(f"Invalidated name-based cache: {name_key}")
-
-        return was_cached
-
-    async def _create_from_database_id(
-        self, database_id: str, token: Optional[str]
-    ) -> NotionDatabase:
-        """Create a NotionDatabase from database ID via API."""
-        formatted_id = format_uuid(database_id) or database_id
-
-        async with NotionDatabaseClient(token=token) as client:
-            db_response = await client.get_database(formatted_id)
-            return self._create_from_response(db_response, token)
-
-    async def _create_from_database_name(
-        self,
-        database_name: str,
-        token: Optional[str] = None,
-        min_similarity: float = 0.6,
-    ) -> NotionDatabase:
-        """Create a NotionDatabase by finding it via name with fuzzy matching."""
-        async with NotionDatabaseClient(token=token) as client:
-            search_result = await client.search_databases(database_name, limit=10)
-
-            if not search_result.results:
-                self.logger.warning("No databases found for name: %s", database_name)
-                raise DatabaseNotFoundException(database_name)
-
-            best_match = find_best_match(
-                query=database_name,
-                items=search_result.results,
-                text_extractor=lambda db: self._extract_title(db),
-                min_similarity=min_similarity,
-            )
-
-            if not best_match:
-                available_titles = [
-                    self._extract_title(db) for db in search_result.results[:5]
-                ]
-                self.logger.warning(
-                    "No sufficiently similar database found for '%s' (min: %.3f). Available: %s",
-                    database_name,
-                    min_similarity,
-                    available_titles,
-                )
-                raise DatabaseNotFoundException(database_name)
-
-            database_id = best_match.item.id
-            db_response = await client.get_database(database_id=database_id)
-            instance = self._create_from_response(db_response, token)
-
-            self.logger.info(
-                "Created database: '%s' (ID: %s, similarity: %.3f)",
-                instance.title,
-                database_id,
-                best_match.similarity,
-            )
-
-            return instance
-
-    def _should_use_cache(self, cache_key: str, force_refresh: bool) -> bool:
-        """Returns True if the cache should be used for the given cache_key."""
-        return not force_refresh and cache_key in self._database_cache
-
-    def _cache_database(
-        self,
-        database: NotionDatabase,
-        token: Optional[str],
-        original_name: Optional[str] = None,
-    ) -> None:
-        """Cache a database by both ID and name (if provided)."""
-        # Always cache by ID
-        id_cache_key = self._create_id_cache_key(database.id)
-        self._database_cache[id_cache_key] = database
-
-        if original_name:
-            name_cache_key = self._create_name_cache_key(original_name, token)
-            self._database_cache[name_cache_key] = database
-
-    def _create_id_cache_key(self, database_id: str) -> str:
-        """Create cache key for database ID."""
-        return f"id:{database_id}"
-
-    def _create_name_cache_key(self, database_name: str, token: Optional[str]) -> str:
-        """Create cache key for database name."""
-        token_suffix = f":{hash(token)}" if token else ":default"
-        return f"name:{database_name.lower().strip()}{token_suffix}"
-
-    def _create_from_response(
-        self, db_response: NotionDatabaseResponse, token: Optional[str]
-    ) -> NotionDatabase:
-        """Create NotionDatabase instance from API response."""
-        from notionary import NotionDatabase
-
-        title = self._extract_title(db_response)
-        emoji_icon = self._extract_emoji_icon(db_response)
-
-        instance = NotionDatabase(
-            id=db_response.id,
-            title=title,
-            url=db_response.url,
-            emoji_icon=emoji_icon,
-            properties=db_response.properties,
-            token=token,
-        )
-
-        self.logger.info(
-            "Created database manager: '%s' (ID: %s)", title, db_response.id
-        )
-
-        return instance
-
-    def _extract_title(self, db_response: NotionDatabaseResponse) -> str:
-        """Extract title from database response."""
-        if db_response.title and len(db_response.title) > 0:
-            return db_response.title[0].plain_text
-        return "Untitled Database"
-
-    def _extract_emoji_icon(self, db_response: NotionDatabaseResponse) -> Optional[str]:
-        """Extract emoji from database response."""
-        if not db_response.icon:
-            return None
-
-        if db_response.icon.type == "emoji":
-            return db_response.icon.emoji
-
-        return None

notionary/database/exceptions.py

@@ -1,13 +0,0 @@
-class NotionDatabaseException(Exception):
-    """Base exception for all Notion database operations."""
-
-    pass
-
-
-class DatabaseNotFoundException(NotionDatabaseException):
-    """Exception raised when a database is not found."""
-
-    def __init__(self, identifier: str, message: str = None):
-        self.identifier = identifier
-        self.message = message or f"Database not found: {identifier}"
-        super().__init__(self.message)

notionary/database/models.py

@@ -1,337 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Dict, List, Literal, Optional, Union
-
-from pydantic import BaseModel, ConfigDict
-
-from notionary.page.models import Cover, Icon
-
-
-@dataclass
-class TextContent:
-    content: str
-    link: Optional[str] = None
-
-
-@dataclass
-class RichText:
-    type: str
-    text: TextContent
-    plain_text: str
-    href: Optional[str]
-
-
-@dataclass
-class User:
-    object: str
-    id: str
-
-
-@dataclass
-class Parent:
-    type: Literal["page_id", "workspace", "block_id", "database_id"]
-    page_id: Optional[str] = None
-    block_id: Optional[str] = None
-    database_id: Optional[str] = None
-
-
-# Rich text types for Pydantic models
-class TextContentPydantic(BaseModel):
-    content: str
-    link: Optional[Dict[str, str]] = None
-
-
-class Annotations(BaseModel):
-    bold: bool
-    italic: bool
-    strikethrough: bool
-    underline: bool
-    code: bool
-    color: str
-
-
-class RichTextItemPydantic(BaseModel):
-    type: str  # 'text', 'mention', 'equation'
-    text: Optional[TextContentPydantic] = None
-    annotations: Annotations
-    plain_text: str
-    href: Optional[str] = None
-
-
-# Database property schema types (these are schema definitions, not values)
-class StatusOption(BaseModel):
-    id: str
-    name: str
-    color: str
-    description: Optional[str] = None
-
-
-class StatusGroup(BaseModel):
-    id: str
-    name: str
-    color: str
-    option_ids: List[str]
-
-
-class StatusPropertySchema(BaseModel):
-    options: List[StatusOption]
-    groups: List[StatusGroup]
-
-
-class DatabaseStatusProperty(BaseModel):
-    id: str
-    name: str
-    type: Literal["status"]
-    status: StatusPropertySchema
-
-
-class RelationPropertySchema(BaseModel):
-    database_id: str
-    type: str  # "single_property"
-    single_property: Dict[str, Any]
-
-
-class DatabaseRelationProperty(BaseModel):
-    id: str
-    name: str
-    type: Literal["relation"]
-    relation: RelationPropertySchema
-
-
-class DatabaseUrlProperty(BaseModel):
-    id: str
-    name: str
-    type: Literal["url"]
-    url: Dict[str, Any]  # Usually empty dict
-
-
-class DatabaseRichTextProperty(BaseModel):
-    id: str
-    name: str
-    type: Literal["rich_text"]
-    rich_text: Dict[str, Any]  # Usually empty dict
-
-
-class MultiSelectOption(BaseModel):
-    id: str
-    name: str
-    color: str
-    description: Optional[str] = None
-
-
-class MultiSelectPropertySchema(BaseModel):
-    options: List[MultiSelectOption]
-
-
-class DatabaseMultiSelectProperty(BaseModel):
-    id: str
-    name: str
-    type: Literal["multi_select"]
-    multi_select: MultiSelectPropertySchema
-
-
-class DatabaseTitleProperty(BaseModel):
-    id: str
-    name: str
-    type: Literal["title"]
-    title: Dict[str, Any]  # Usually empty dict
-
-
-# Generic database property for unknown types
-class GenericDatabaseProperty(BaseModel):
-    id: str
-    name: str
-    type: str
-
-    model_config = ConfigDict(extra="allow")
-
-
-# Union of all database property types
-DatabaseProperty = Union[
-    DatabaseStatusProperty,
-    DatabaseRelationProperty,
-    DatabaseUrlProperty,
-    DatabaseRichTextProperty,
-    DatabaseMultiSelectProperty,
-    DatabaseTitleProperty,
-    GenericDatabaseProperty,
-]
-
-
-# Page property value types (these are actual values, not schemas)
-class StatusValue(BaseModel):
-    id: str
-    name: str
-    color: str
-
-
-class StatusProperty(BaseModel):
-    id: str
-    type: str  # 'status'
-    status: Optional[StatusValue] = None
-
-
-class RelationItem(BaseModel):
-    id: str
-
-
-class RelationProperty(BaseModel):
-    id: str
-    type: str  # 'relation'
-    relation: List[RelationItem]
-    has_more: bool
-
-
-class UrlProperty(BaseModel):
-    id: str
-    type: str  # 'url'
-    url: Optional[str] = None
-
-
-class RichTextProperty(BaseModel):
-    id: str
-    type: str  # 'rich_text'
-    rich_text: List[RichTextItemPydantic]
-
-
-class MultiSelectItem(BaseModel):
-    id: str
-    name: str
-    color: str
-
-
-class MultiSelectProperty(BaseModel):
-    id: str
-    type: str  # 'multi_select'
-    multi_select: List[MultiSelectItem]
-
-
-class TitleProperty(BaseModel):
-    id: str
-    type: str  # 'title'
-    title: List[RichTextItemPydantic]
-
-
-# Cover types
-class ExternalCover(BaseModel):
-    url: str
-
-
-class NotionCover(BaseModel):
-    type: str  # 'external', 'file'
-    external: Optional[ExternalCover] = None
-
-
-# Parent types for Pydantic
-class NotionParent(BaseModel):
-    type: str  # 'database_id', 'page_id', 'workspace'
-    database_id: Optional[str] = None
-    page_id: Optional[str] = None
-
-
-# User type for Pydantic
-class NotionUser(BaseModel):
-    object: str  # 'user'
-    id: str
-
-
-# Database object
-class NotionDatabaseResponse(BaseModel):
-    """
-    Represents the response from the Notion API when retrieving a database.
-    """
-
-    object: Literal["database"]
-    id: str
-    cover: Optional[Any] = None
-    icon: Optional[Icon] = None
-    cover: Optional[Cover]
-    created_time: str
-    last_edited_time: str
-    created_by: NotionUser
-    last_edited_by: NotionUser
-    title: List[RichTextItemPydantic]
-    description: List[Any]
-    is_inline: bool
-    properties: Dict[
-        str, Any
-    ]  # Using Any for flexibility with different property schemas
-    parent: NotionParent
-    url: str
-    public_url: Optional[str] = None
-    archived: bool
-    in_trash: bool
-
-
-class NotionPageResponse(BaseModel):
-    object: Literal["page"]
-    id: str
-    created_time: str
-    last_edited_time: str
-    created_by: NotionUser
-    last_edited_by: NotionUser
-    cover: Optional[NotionCover] = None
-    icon: Optional[Icon] = None
-    parent: NotionParent
-    archived: bool
-    in_trash: bool
-    properties: Dict[str, Any]
-    url: str
-    public_url: Optional[str] = None
-
-
-class NotionQueryResponse(BaseModel):
-    """
-    Complete Notion search/query response model that can contain both pages and databases.
-    """
-
-    object: Literal["list"]
-    results: List[Union[NotionPageResponse, NotionDatabaseResponse]]
-    next_cursor: Optional[str] = None
-    has_more: bool
-    type: Literal["page_or_database"]
-    page_or_database: Dict[str, Any]
-    request_id: str
-
-
-# Specific response type for database queries (pages only)
-class NotionQueryDatabaseResponse(BaseModel):
-    """
-    Notion database query response model for querying pages within a database.
-    """
-
-    object: Literal["list"]
-    results: List[NotionPageResponse]
-    next_cursor: Optional[str] = None
-    has_more: bool
-    type: Literal["page_or_database"]
-    page_or_database: Dict[str, Any]
-    request_id: str
-
-
-# Specific response type for search results (can be mixed)
-class NotionSearchResponse(BaseModel):
-    """
-    Notion search response model that can return both pages and databases.
-    """
-
-    object: Literal["list"]
-    results: List[Union[NotionPageResponse, NotionDatabaseResponse]]
-    next_cursor: Optional[str] = None
-    has_more: bool
-    type: Literal["page_or_database"]
-    page_or_database: Dict[str, Any]
-    request_id: str
-
-
-class NotionDatabaseSearchResponse(BaseModel):
-    """
-    Notion search response model for database-only searches.
-    """
-
-    object: Literal["list"]
-    results: List[NotionDatabaseResponse]
-    next_cursor: Optional[str] = None
-    has_more: bool
-    type: Literal["page_or_database"]
-    page_or_database: Dict[str, Any]
-    request_id: str