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

notionary/data_source/service.py

@@ -0,0 +1,377 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncIterator, Callable
+from typing import TYPE_CHECKING, Self
+
+from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMarkdownConverter
+from notionary.data_source.http.client import DataSourceClient
+from notionary.data_source.http.data_source_instance_client import DataSourceInstanceClient
+from notionary.data_source.properties.schemas import (
+    DataSourceMultiSelectProperty,
+    DataSourceProperty,
+    DataSourcePropertyOption,
+    DataSourcePropertyT,
+    DataSourceRelationProperty,
+    DataSourceSelectProperty,
+    DataSourceStatusProperty,
+)
+from notionary.data_source.query.builder import DataSourceQueryBuilder
+from notionary.data_source.query.resolver import QueryResolver
+from notionary.data_source.query.schema import (
+    DataSourceQueryParams,
+)
+from notionary.data_source.schema.service import DataSourcePropertySchemaFormatter
+from notionary.data_source.schemas import DataSourceDto
+from notionary.exceptions.data_source.properties import DataSourcePropertyNotFound, DataSourcePropertyTypeError
+from notionary.page.properties.models import PageTitleProperty
+from notionary.page.schemas import NotionPageDto
+from notionary.shared.entity.dto_parsers import (
+    extract_cover_image_url_from_dto,
+    extract_database_id,
+    extract_description,
+    extract_emoji_icon_from_dto,
+    extract_external_icon_url_from_dto,
+    extract_title,
+)
+from notionary.shared.entity.entity_metadata_update_client import EntityMetadataUpdateClient
+from notionary.shared.entity.service import Entity
+from notionary.user.schemas import PartialUserDto
+from notionary.workspace.query.service import WorkspaceQueryService
+
+if TYPE_CHECKING:
+    from notionary import NotionDatabase, NotionPage
+
+
+class NotionDataSource(Entity):
+    def __init__(
+        self,
+        id: str,
+        title: str,
+        created_time: str,
+        created_by: PartialUserDto,
+        last_edited_time: str,
+        last_edited_by: PartialUserDto,
+        archived: bool,
+        in_trash: bool,
+        url: str,
+        properties: dict[str, DataSourceProperty],
+        parent_database_id: str | None,
+        emoji_icon: str | None = None,
+        external_icon_url: str | None = None,
+        cover_image_url: str | None = None,
+        description: str | None = None,
+        public_url: str | None = None,
+        data_source_instance_client: DataSourceInstanceClient | None = None,
+        query_resolver: QueryResolver | None = None,
+    ) -> None:
+        super().__init__(
+            id=id,
+            created_time=created_time,
+            created_by=created_by,
+            last_edited_time=last_edited_time,
+            last_edited_by=last_edited_by,
+            in_trash=in_trash,
+            emoji_icon=emoji_icon,
+            external_icon_url=external_icon_url,
+            cover_image_url=cover_image_url,
+        )
+        self._parent_database_id = parent_database_id
+        self._parent_database: NotionDatabase | None = None
+        self._title = title
+        self._archived = archived
+        self._url = url
+        self._public_url = public_url
+        self._description = description
+        self._properties = properties or {}
+        self._data_source_client = data_source_instance_client or DataSourceInstanceClient(data_source_id=id)
+        self.query_resolver = query_resolver or QueryResolver()
+
+    @classmethod
+    async def from_id(
+        cls,
+        data_source_id: str,
+        data_source_client: DataSourceClient | None = None,
+        rich_text_converter: RichTextToMarkdownConverter | None = None,
+    ) -> Self:
+        client = data_source_client or DataSourceClient()
+        converter = rich_text_converter or RichTextToMarkdownConverter()
+        data_source_dto = await client.get_data_source(data_source_id)
+        return await cls._create_from_dto(data_source_dto, converter)
+
+    @classmethod
+    async def from_title(
+        cls,
+        data_source_title: str,
+        search_service: WorkspaceQueryService | None = None,
+    ) -> Self:
+        service = search_service or WorkspaceQueryService()
+        return await service.find_data_source(data_source_title)
+
+    @classmethod
+    async def _create_from_dto(
+        cls,
+        response: DataSourceDto,
+        rich_text_converter: RichTextToMarkdownConverter,
+    ) -> Self:
+        title, description = await asyncio.gather(
+            extract_title(response, rich_text_converter),
+            extract_description(response, rich_text_converter),
+        )
+
+        parent_database_id = extract_database_id(response)
+
+        return cls._create(
+            id=response.id,
+            title=title,
+            description=description,
+            created_time=response.created_time,
+            created_by=response.created_by,
+            last_edited_time=response.last_edited_time,
+            last_edited_by=response.last_edited_by,
+            archived=response.archived,
+            in_trash=response.in_trash,
+            url=response.url,
+            properties=response.properties,
+            parent_database_id=parent_database_id,
+            emoji_icon=extract_emoji_icon_from_dto(response),
+            external_icon_url=extract_external_icon_url_from_dto(response),
+            cover_image_url=extract_cover_image_url_from_dto(response),
+            public_url=response.url,
+        )
+
+    @classmethod
+    def _create(
+        cls,
+        id: str,
+        title: str,
+        created_time: str,
+        created_by: PartialUserDto,
+        last_edited_time: str,
+        last_edited_by: PartialUserDto,
+        archived: bool,
+        in_trash: bool,
+        url: str,
+        properties: dict[str, DataSourceProperty],
+        parent_database_id: str | None,
+        emoji_icon: str | None = None,
+        external_icon_url: str | None = None,
+        cover_image_url: str | None = None,
+        description: str | None = None,
+        public_url: str | None = None,
+    ) -> Self:
+        data_source_instance_client = DataSourceInstanceClient(data_source_id=id)
+        return cls(
+            id=id,
+            title=title,
+            created_time=created_time,
+            created_by=created_by,
+            last_edited_time=last_edited_time,
+            last_edited_by=last_edited_by,
+            archived=archived,
+            in_trash=in_trash,
+            url=url,
+            parent_database_id=parent_database_id,
+            emoji_icon=emoji_icon,
+            external_icon_url=external_icon_url,
+            cover_image_url=cover_image_url,
+            description=description,
+            public_url=public_url,
+            properties=properties,
+            data_source_instance_client=data_source_instance_client,
+        )
+
+    @property
+    def _entity_metadata_update_client(self) -> EntityMetadataUpdateClient:
+        return self._data_source_client
+
+    @property
+    def title(self) -> str:
+        return self._title
+
+    @property
+    def archived(self) -> bool:
+        return self._archived
+
+    @property
+    def description(self) -> str | None:
+        return self._description
+
+    @property
+    def properties(self) -> dict[str, DataSourceProperty]:
+        return self._properties
+
+    @property
+    def url(self) -> str:
+        return self._url
+
+    @property
+    def public_url(self) -> str | None:
+        return self._public_url
+
+    async def get_parent_database(self) -> NotionDatabase | None:
+        if self._parent_database is None and self._parent_database_id:
+            self._parent_database = await NotionDatabase.from_id(self._parent_database_id)
+        return self._parent_database
+
+    async def create_blank_page(self, title: str | None = None) -> NotionPage:
+        return await self._data_source_client.create_blank_page(title=title)
+
+    async def set_title(self, title: str) -> None:
+        data_source_dto = await self._data_source_client.update_title(title)
+        self._title = data_source_dto.title
+
+    async def archive(self) -> None:
+        if self._archived:
+            self.logger.info("Data source is already archived.")
+            return
+        await self._data_source_client.archive()
+        self._archived = True
+
+    async def unarchive(self) -> None:
+        if not self._archived:
+            self.logger.info("Data source is not archived.")
+            return
+        await self._data_source_client.unarchive()
+        self._archived = False
+
+    async def update_description(self, description: str) -> None:
+        self._description = await self._data_source_client.update_description(description)
+
+    async def get_options_for_property_by_name(self, property_name: str) -> list[str]:
+        prop = self._properties.get(property_name)
+
+        if prop is None:
+            return []
+
+        if isinstance(prop, DataSourceSelectProperty):
+            return prop.option_names
+
+        if isinstance(prop, DataSourceMultiSelectProperty):
+            return prop.option_names
+
+        if isinstance(prop, DataSourceStatusProperty):
+            return prop.option_names
+
+        if isinstance(prop, DataSourceRelationProperty):
+            return await self._get_relation_options(prop)
+
+        return []
+
+    def get_select_options_by_property_name(self, property_name: str) -> list[str]:
+        select_prop = self._get_typed_property_or_raise(property_name, DataSourceSelectProperty)
+        return select_prop.option_names
+
+    def get_multi_select_options_by_property_name(self, property_name: str) -> list[DataSourcePropertyOption]:
+        multi_select_prop = self._get_typed_property_or_raise(property_name, DataSourceMultiSelectProperty)
+        return multi_select_prop.option_names
+
+    def get_status_options_by_property_name(self, property_name: str) -> list[str]:
+        status_prop = self._get_typed_property_or_raise(property_name, DataSourceStatusProperty)
+        return status_prop.option_names
+
+    async def get_relation_options_by_property_name(self, property_name: str) -> list[str]:
+        relation_prop = self._get_typed_property_or_raise(property_name, DataSourceRelationProperty)
+        return await self._get_relation_options(relation_prop)
+
+    async def _get_relation_options(self, relation_prop: DataSourceRelationProperty) -> list[str]:
+        related_data_source_id = relation_prop.related_data_source_id
+        if not related_data_source_id:
+            return []
+
+        async with DataSourceInstanceClient(related_data_source_id) as related_client:
+            search_results = await related_client.query()
+
+        page_titles = []
+        for page_response in search_results.results:
+            title = self._extract_title_from_notion_page_dto(page_response)
+            if title:
+                page_titles.append(title)
+
+        return page_titles
+
+    def _extract_title_from_notion_page_dto(self, page: NotionPageDto) -> str | None:
+        if not page.properties:
+            return None
+
+        title_property = next(
+            (prop for prop in page.properties.values() if isinstance(prop, PageTitleProperty)),
+            None,
+        )
+
+        if not title_property:
+            return None
+
+        return "".join(item.plain_text for item in title_property.title)
+
+    def _get_typed_property_or_raise(self, name: str, property_type: type[DataSourcePropertyT]) -> DataSourcePropertyT:
+        prop = self._properties.get(name)
+
+        if prop is None:
+            raise DataSourcePropertyNotFound(
+                property_name=name,
+                available_properties=list(self._properties.keys()),
+            )
+
+        if not isinstance(prop, property_type):
+            raise DataSourcePropertyTypeError(
+                property_name=name, expected_type=property_type.__name__, actual_type=type(prop).__name__
+            )
+
+        return prop
+
+    def filter(self) -> DataSourceQueryBuilder:
+        return DataSourceQueryBuilder(properties=self._properties)
+
+    async def query_pages(
+        self, filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder]
+    ) -> list[NotionPage]:
+        builder = DataSourceQueryBuilder(properties=self._properties)
+        configured_builder = filter_fn(builder)
+        query_params = configured_builder.build()
+
+        return await self.get_pages(query_params)
+
+    async def query_pages_stream(
+        self, filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder]
+    ) -> AsyncIterator[NotionPage]:
+        builder = DataSourceQueryBuilder(properties=self._properties)
+        configured_builder = filter_fn(builder)
+        query_params = configured_builder.build()
+
+        async for page in self.get_pages_stream(query_params):
+            yield page
+
+    async def get_pages(
+        self,
+        query_params: DataSourceQueryParams | None = None,
+    ) -> list[NotionPage]:
+        from notionary import NotionPage
+
+        resolved_params = await self._resolve_query_params_if_needed(query_params)
+        query_response = await self._data_source_client.query(query_params=resolved_params)
+        return [await NotionPage.from_id(page.id) for page in query_response.results]
+
+    async def get_pages_stream(
+        self,
+        query_params: DataSourceQueryParams | None = None,
+    ) -> AsyncIterator[NotionPage]:
+        from notionary import NotionPage
+
+        resolved_params = await self._resolve_query_params_if_needed(query_params)
+
+        async for page in self._data_source_client.query_stream(query_params=resolved_params):
+            yield await NotionPage.from_id(page.id)
+
+    async def _resolve_query_params_if_needed(
+        self,
+        query_params: DataSourceQueryParams | None,
+    ) -> DataSourceQueryParams | None:
+        if query_params is None:
+            return None
+
+        return await self.query_resolver.resolve_params(query_params)
+
+    async def get_schema_description(self) -> str:
+        formatter = DataSourcePropertySchemaFormatter(relation_options_fetcher=self._get_relation_options)
+        return await formatter.format(title=self._title, description=self._description, properties=self._properties)

notionary/database/client.py

@@ -1,148 +1,43 @@
-from typing import Any, Dict, Optional
-
-from notionary.base_notion_client import BaseNotionClient
-from notionary.database.models import (
-    NotionDatabaseResponse,
-    NotionDatabaseSearchResponse,
-    NotionPageResponse,
-    NotionQueryDatabaseResponse,
+from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMarkdownConverter
+from notionary.database.schemas import (
+    NotionDatabaseDto,
+    NotionDatabaseUpdateDto,
 )
+from notionary.http.client import NotionHttpClient
 
 
-class NotionDatabaseClient(BaseNotionClient):
-    """
-    Specialized Notion client for database operations.
-    Inherits connection management and HTTP methods from BaseNotionClient.
-    """
-
-    def __init__(self, token: Optional[str] = None, timeout: int = 30):
-        super().__init__(token, timeout)
-
-    async def create_database(
-        self,
-        title: str,
-        parent_page_id: Optional[str],
-        properties: Optional[Dict[str, Any]] = None,
-    ) -> NotionDatabaseResponse:
-        """
-        Creates a new database as child of the specified page.
-        """
-        if properties is None:
-            properties = {"Name": {"title": {}}}
-
-        database_data = {
-            "parent": {"page_id": parent_page_id},
-            "title": [{"type": "text", "text": {"content": title}}],
-            "properties": properties,
-        }
-
-        response = await self.post("databases", database_data)
-        return NotionDatabaseResponse.model_validate(response)
-
-    async def get_database(self, database_id: str) -> NotionDatabaseResponse:
-        """
-        Gets metadata for a Notion database by its ID.
-        """
-        response = await self.get(f"databases/{database_id}")
-        return NotionDatabaseResponse.model_validate(response)
-
-    async def patch_database(
-        self, database_id: str, data: Dict[str, Any]
-    ) -> NotionDatabaseResponse:
-        """
-        Updates a Notion database with the provided data.
-        """
-        response = await self.patch(f"databases/{database_id}", data=data)
-        return NotionDatabaseResponse.model_validate(response)
-
-    async def query_database(
-        self, database_id: str, query_data: Dict[str, Any] = None
-    ) -> NotionQueryDatabaseResponse:
-        """
-        Queries a Notion database with the provided filter and sorts.
-        """
-        response = await self.post(f"databases/{database_id}/query", data=query_data)
-        return NotionQueryDatabaseResponse.model_validate(response)
+class NotionDatabaseHttpClient(NotionHttpClient):
+    def __init__(self, database_id: str, timeout: int = 30) -> None:
+        super().__init__(timeout)
+        self._database_id = database_id
 
-    async def query_database_by_title(
-        self, database_id: str, page_title: str
-    ) -> NotionQueryDatabaseResponse:
-        """
-        Queries a Notion database by title.
-        """
-        query_data = {
-            "filter": {"property": "title", "title": {"contains": page_title}}
-        }
+    async def get_database(self) -> NotionDatabaseDto:
+        response = await self.get(f"databases/{self._database_id}")
+        return NotionDatabaseDto.model_validate(response)
 
-        return await self.query_database(database_id=database_id, query_data=query_data)
+    async def patch_database(self, update_database_dto: NotionDatabaseUpdateDto) -> NotionDatabaseDto:
+        update_database_dto_dict = update_database_dto.model_dump(exclude_none=True)
 
-    async def search_databases(
-        self, query: str = "", sort_ascending: bool = True, limit: int = 100
-    ) -> NotionDatabaseSearchResponse:
-        """
-        Searches for databases in Notion using the search endpoint.
+        response = await self.patch(f"databases/{self._database_id}", data=update_database_dto_dict)
+        return NotionDatabaseDto.model_validate(response)
 
-        Args:
-            query: Search query string
-            sort_ascending: Whether to sort in ascending order
-            limit: Maximum number of results to return
-        """
-        search_data = {
-            "query": query,
-            "filter": {"value": "database", "property": "object"},
-            "sort": {
-                "direction": "ascending" if sort_ascending else "descending",
-                "timestamp": "last_edited_time",
-            },
-            "page_size": limit,
-        }
+    async def update_database_title(self, title: str) -> NotionDatabaseDto:
+        from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
 
-        response = await self.post("search", search_data)
-        return NotionDatabaseSearchResponse.model_validate(response)
+        markdown_rich_text_formatter = MarkdownRichTextConverter()
+        database_rich_text = await markdown_rich_text_formatter.to_rich_text(title)
 
-    async def create_page(self, parent_database_id: str) -> NotionPageResponse:
-        """
-        Creates a new blank page in the given database with minimal properties.
-        """
-        page_data = {
-            "parent": {"database_id": parent_database_id},
-            "properties": {},
-        }
-        response = await self.post("pages", page_data)
-        return NotionPageResponse.model_validate(response)
+        database_title_update_dto = NotionDatabaseUpdateDto(title=database_rich_text)
+        return await self.patch_database(database_title_update_dto)
 
-    async def update_database_title(
-        self, database_id: str, title: str
-    ) -> NotionDatabaseResponse:
-        """
-        Updates the title of a database.
-        """
-        data = {"title": [{"text": {"content": title}}]}
-        return await self.patch_database(database_id, data)
+    async def update_database_description(self, description: str) -> str:
+        from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
 
-    async def update_database_emoji(
-        self, database_id: str, emoji: str
-    ) -> NotionDatabaseResponse:
-        """
-        Updates the emoji/icon of a database.
-        """
-        data = {"icon": {"type": "emoji", "emoji": emoji}}
-        return await self.patch_database(database_id, data)
+        markdown_to_rich_text_converter = MarkdownRichTextConverter()
+        rich_text_description = await markdown_to_rich_text_converter.to_rich_text(description)
 
-    async def update_database_cover_image(
-        self, database_id: str, image_url: str
-    ) -> NotionDatabaseResponse:
-        """
-        Updates the cover image of a database.
-        """
-        data = {"cover": {"type": "external", "external": {"url": image_url}}}
-        return await self.patch_database(database_id, data)
+        database_description_update_dto = NotionDatabaseUpdateDto(description=rich_text_description)
+        update_database_response = await self.patch_database(database_description_update_dto)
 
-    async def update_database_external_icon(
-        self, database_id: str, icon_url: str
-    ) -> NotionDatabaseResponse:
-        """
-        Updates the database icon with an external image URL.
-        """
-        data = {"icon": {"type": "external", "external": {"url": icon_url}}}
-        return await self.patch_database(database_id, data)
+        rich_text_to_markdown_converter = RichTextToMarkdownConverter()
+        return await rich_text_to_markdown_converter.to_markdown(update_database_response.description)

notionary/database/database_metadata_update_client.py

@@ -0,0 +1,19 @@
+from typing import override
+
+from notionary.database.schemas import NotionDatabaseDto
+from notionary.http.client import NotionHttpClient
+from notionary.shared.entity.entity_metadata_update_client import EntityMetadataUpdateClient
+from notionary.shared.entity.schemas import NotionEntityUpdateDto
+
+
+class DatabaseMetadataUpdateClient(NotionHttpClient, EntityMetadataUpdateClient):
+    def __init__(self, database_id: str, timeout: int = 30) -> None:
+        super().__init__(timeout)
+        self._database_id = database_id
+
+    @override
+    async def patch_metadata(self, updated_data: NotionEntityUpdateDto) -> NotionDatabaseDto:
+        updated_data_dict = updated_data.model_dump(exclude_unset=True, exclude_none=True)
+
+        response_dict = await self.patch(f"databases/{self._database_id}", data=updated_data_dict)
+        return NotionDatabaseDto.model_validate(response_dict)

notionary/database/schemas.py

@@ -0,0 +1,29 @@
+from pydantic import BaseModel, Field
+
+from notionary.blocks.rich_text.models import RichText
+from notionary.shared.entity.schemas import EntityResponseDto
+from notionary.shared.models.cover import NotionCover
+from notionary.shared.models.icon import Icon
+
+
+class _DataSourceDiscoveryDto(BaseModel):
+    id: str
+    name: str
+
+
+class NotionDatabaseDto(EntityResponseDto):
+    title: list[RichText]
+    description: list[RichText]
+    is_inline: bool
+    is_locked: bool
+    data_sources: list[_DataSourceDiscoveryDto] = Field(default_factory=list)
+    url: str
+    public_url: str | None = None
+
+
+class NotionDatabaseUpdateDto(BaseModel):
+    title: list[RichText] | None = None
+    icon: Icon | None = None
+    cover: NotionCover | None = None
+    archived: bool | None = None
+    description: list[RichText] | None = None