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

notionary/data_source/service.py

@@ -7,7 +7,7 @@ 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.models import (
+from notionary.data_source.properties.schemas import (
     DataSourceMultiSelectProperty,
     DataSourceProperty,
     DataSourcePropertyOption,
@@ -16,26 +16,18 @@ from notionary.data_source.properties.models import (
     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.query import DataSourceQueryBuilder, DataSourceQueryParams, QueryResolver
+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:
@@ -45,41 +37,21 @@ if TYPE_CHECKING:
 class NotionDataSource(Entity):
     def __init__(
         self,
-        id: str,
+        dto: DataSourceDto,
         title: str,
-        created_time: str,
-        created_by: PartialUserDto,
-        last_edited_time: str,
-        last_edited_by: PartialUserDto,
-        archived: bool,
-        in_trash: bool,
+        description: str | None,
         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,
-        data_source_instance_client: DataSourceInstanceClient | None = None,
+        data_source_instance_client: DataSourceInstanceClient,
         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
+        super().__init__(dto=dto)
+
         self._parent_database: NotionDatabase | None = None
         self._title = title
-        self._archived = archived
+        self._archived = dto.archived
         self._description = description
         self._properties = properties or {}
-        self._data_source_client = data_source_instance_client or DataSourceInstanceClient(data_source_id=id)
+        self._data_source_client = data_source_instance_client
         self.query_resolver = query_resolver or QueryResolver()
 
     @classmethod
@@ -98,76 +70,29 @@ class NotionDataSource(Entity):
     async def from_title(
         cls,
         data_source_title: str,
-        min_similarity: float = 0.6,
         search_service: WorkspaceQueryService | None = None,
     ) -> Self:
         service = search_service or WorkspaceQueryService()
-        return await service.find_data_source(data_source_title, min_similarity=min_similarity)
+        return await service.find_data_source(data_source_title)
 
     @classmethod
     async def _create_from_dto(
         cls,
-        response: DataSourceDto,
+        dto: DataSourceDto,
         rich_text_converter: RichTextToMarkdownConverter,
     ) -> Self:
         title, description = await asyncio.gather(
-            extract_title(response, rich_text_converter),
-            extract_description(response, rich_text_converter),
+            extract_title(dto, rich_text_converter),
+            extract_description(dto, 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,
-            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),
-        )
+        data_source_instance_client = DataSourceInstanceClient(data_source_id=dto.id)
 
-    @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,
-        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,
-    ) -> Self:
-        data_source_instance_client = DataSourceInstanceClient(data_source_id=id)
         return cls(
-            id=id,
+            dto=dto,
             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,
-            parent_database_id=parent_database_id,
-            emoji_icon=emoji_icon,
-            external_icon_url=external_icon_url,
-            cover_image_url=cover_image_url,
             description=description,
-            properties=properties,
+            properties=dto.properties,
             data_source_instance_client=data_source_instance_client,
         )
 
@@ -191,11 +116,6 @@ class NotionDataSource(Entity):
     def properties(self) -> dict[str, DataSourceProperty]:
         return self._properties
 
-    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)
 
@@ -305,19 +225,21 @@ class NotionDataSource(Entity):
     def filter(self) -> DataSourceQueryBuilder:
         return DataSourceQueryBuilder(properties=self._properties)
 
-    async def query(self, filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder]) -> list[NotionPage]:
+    async def query_pages(
+        self, filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder]
+    ) -> list[NotionPage]:
         builder = DataSourceQueryBuilder(properties=self._properties)
-        filter_fn(builder)
-        query_params = builder.build()
+        configured_builder = filter_fn(builder)
+        query_params = configured_builder.build()
 
         return await self.get_pages(query_params)
 
-    async def query_stream(
+    async def query_pages_stream(
         self, filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder]
     ) -> AsyncIterator[NotionPage]:
         builder = DataSourceQueryBuilder(properties=self._properties)
-        filter_fn(builder)
-        query_params = builder.build()
+        configured_builder = filter_fn(builder)
+        query_params = configured_builder.build()
 
         async for page in self.get_pages_stream(query_params):
             yield page
@@ -351,3 +273,7 @@ class NotionDataSource(Entity):
             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/service.py

@@ -10,14 +10,10 @@ from notionary.database.client import NotionDatabaseHttpClient
 from notionary.database.database_metadata_update_client import DatabaseMetadataUpdateClient
 from notionary.database.schemas import NotionDatabaseDto
 from notionary.shared.entity.dto_parsers import (
-    extract_cover_image_url_from_dto,
     extract_description,
-    extract_emoji_icon_from_dto,
-    extract_external_icon_url_from_dto,
     extract_title,
 )
 from notionary.shared.entity.service import Entity
-from notionary.user.schemas import PartialUserDto
 from notionary.workspace.query.service import WorkspaceQueryService
 
 type DataSourceFactory = Callable[[str], Awaitable[NotionDataSource]]
@@ -26,46 +22,24 @@ type DataSourceFactory = Callable[[str], Awaitable[NotionDataSource]]
 class NotionDatabase(Entity):
     def __init__(
         self,
-        id: str,
+        dto: NotionDatabaseDto,
         title: str,
-        created_time: str,
-        created_by: PartialUserDto,
-        last_edited_time: str,
-        last_edited_by: PartialUserDto,
-        url: str,
-        in_trash: bool,
-        is_inline: bool,
+        description: str | None,
         data_source_ids: list[str],
-        public_url: str | None = None,
-        emoji_icon: str | None = None,
-        external_icon_url: str | None = None,
-        cover_image_url: str | None = None,
-        description: str | None = None,
-        client: NotionDatabaseHttpClient | None = None,
-        metadata_update_client: DatabaseMetadataUpdateClient | None = None,
+        client: NotionDatabaseHttpClient,
+        metadata_update_client: DatabaseMetadataUpdateClient,
     ) -> 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,
-        )
+        super().__init__(dto=dto)
+
         self._title = title
-        self._url = url
-        self._public_url = public_url
         self._description = description
-        self._is_inline = is_inline
+        self._is_inline = dto.is_inline
 
         self._data_sources: list[NotionDataSource] | None = None
         self._data_source_ids = data_source_ids
 
-        self.client = client or NotionDatabaseHttpClient(database_id=id)
-        self._metadata_update_client = metadata_update_client or DatabaseMetadataUpdateClient(database_id=id)
+        self.client = client
+        self._metadata_update_client = metadata_update_client
 
     @classmethod
     async def from_id(
@@ -86,40 +60,31 @@ class NotionDatabase(Entity):
     async def from_title(
         cls,
         database_title: str,
-        min_similarity: float = 0.6,
         search_service: WorkspaceQueryService | None = None,
     ) -> Self:
         service = search_service or WorkspaceQueryService()
-        return await service.find_database(database_title, min_similarity=min_similarity)
+        return await service.find_database(database_title)
 
     @classmethod
     async def _create_from_dto(
         cls,
-        response: NotionDatabaseDto,
+        dto: NotionDatabaseDto,
         rich_text_converter: RichTextToMarkdownConverter,
         client: NotionDatabaseHttpClient,
     ) -> Self:
         title, description = await asyncio.gather(
-            extract_title(response, rich_text_converter), extract_description(response, rich_text_converter)
+            extract_title(dto, rich_text_converter), extract_description(dto, rich_text_converter)
         )
 
+        metadata_update_client = DatabaseMetadataUpdateClient(database_id=dto.id)
+
         return cls(
-            id=response.id,
+            dto=dto,
             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,
-            in_trash=response.in_trash,
-            is_inline=response.is_inline,
-            url=response.url,
-            public_url=response.public_url,
-            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),
-            data_source_ids=[ds.id for ds in response.data_sources],
+            data_source_ids=[ds.id for ds in dto.data_sources],
             client=client,
+            metadata_update_client=metadata_update_client,
         )
 
     @property
@@ -130,14 +95,6 @@ class NotionDatabase(Entity):
     def title(self) -> str:
         return self._title
 
-    @property
-    def url(self) -> str:
-        return self._url
-
-    @property
-    def public_url(self) -> str | None:
-        return self._public_url
-
     @property
     def is_inline(self) -> bool:
         return self._is_inline

notionary/exceptions/__init__.py

@@ -8,7 +8,8 @@ from .api import (
     NotionValidationError,
 )
 from .base import NotionaryError
-from .data_source.properties import DataSourcePropertyNotFound, DataSourcePropertyTypeError
+from .block_parsing import InsufficientColumnsError, InvalidColumnRatioSumError, UnsupportedVideoFormatError
+from .data_source import DataSourcePropertyNotFound, DataSourcePropertyTypeError
 from .properties import AccessPagePropertyWithoutDataSourceError, PagePropertyNotFoundError, PagePropertyTypeError
 from .search import DatabaseNotFound, DataSourceNotFound, EntityNotFound, PageNotFound
 
@@ -19,6 +20,8 @@ __all__ = [
     "DataSourcePropertyTypeError",
     "DatabaseNotFound",
     "EntityNotFound",
+    "InsufficientColumnsError",
+    "InvalidColumnRatioSumError",
     "NotionApiError",
     "NotionAuthenticationError",
     "NotionConnectionError",
@@ -30,4 +33,5 @@ __all__ = [
     "PageNotFound",
     "PagePropertyNotFoundError",
     "PagePropertyTypeError",
+    "UnsupportedVideoFormatError",
 ]

notionary/exceptions/block_parsing.py

@@ -14,3 +14,24 @@ class InvalidColumnRatioSumError(NotionaryError):
         self.total = total
         self.tolerance = tolerance
         super().__init__(f"Width ratios must sum to 1.0 (±{tolerance}), but sum is {total}")
+
+
+class UnsupportedVideoFormatError(ValueError):
+    def __init__(self, url: str, supported_formats: list[str]) -> None:
+        self.url = url
+        self.supported_formats = supported_formats
+        super().__init__(self._create_user_friendly_message())
+
+    def _create_user_friendly_message(self) -> str:
+        formats = ", ".join(self.supported_formats[:5])
+        remaining = len(self.supported_formats) - 5
+
+        if remaining > 0:
+            formats += f" and {remaining} more"
+
+        return (
+            f"The video URL '{self.url}' uses an unsupported format.\n"
+            f"Supported formats include: {formats}.\n"
+            f"YouTube embed and watch URLs are also supported."
+            f"Also see https://developers.notion.com/reference/block#video for more information."
+        )

notionary/exceptions/search.py

@@ -31,3 +31,27 @@ class DataSourceNotFound(EntityNotFound):
 class DatabaseNotFound(EntityNotFound):
     def __init__(self, query: str, available_titles: list[str] | None = None) -> None:
         super().__init__("database", query, available_titles)
+
+
+class NoUsersInWorkspace(NotionaryError):
+    def __init__(self, user_type: str) -> None:
+        self.user_type = user_type
+        message = f"No '{user_type}' users found in the workspace."
+        super().__init__(message)
+
+
+class UserNotFound(NotionaryError):
+    def __init__(self, user_type: str, query: str, available_names: list[str] | None = None) -> None:
+        self.user_type = user_type
+        self.query = query
+        self.available_names = available_names or []
+
+        if self.available_names:
+            message = (
+                f"No '{user_type}' user found with exact name '{query}'. "
+                f"Did you mean one of these? {self.available_names}"
+            )
+        else:
+            message = f"No '{user_type}' user found with name '{query}'."
+
+        super().__init__(message)

notionary/http/client.py

@@ -1,6 +1,5 @@
 import asyncio
 import os
-from typing import Any
 
 import httpx
 from dotenv import load_dotenv
@@ -16,6 +15,7 @@ from notionary.exceptions.api import (
     NotionValidationError,
 )
 from notionary.http.models import HttpMethod
+from notionary.shared.typings import JsonDict
 from notionary.utils.mixins.logging import LoggingMixin
 
 load_dotenv()
@@ -80,25 +80,25 @@ class NotionHttpClient(LoggingMixin):
         self._is_initialized = False
         self.logger.debug("NotionHttpClient closed")
 
-    async def get(self, endpoint: str, params: dict[str, Any] | None = None) -> dict[str, Any] | None:
+    async def get(self, endpoint: str, params: JsonDict | None = None) -> JsonDict | None:
         return await self.make_request(HttpMethod.GET, endpoint, params=params)
 
-    async def post(self, endpoint: str, data: dict[str, Any] | None = None) -> dict[str, Any] | None:
+    async def post(self, endpoint: str, data: JsonDict | None = None) -> JsonDict | None:
         return await self.make_request(HttpMethod.POST, endpoint, data)
 
-    async def patch(self, endpoint: str, data: dict[str, Any] | None = None) -> dict[str, Any] | None:
+    async def patch(self, endpoint: str, data: JsonDict | None = None) -> JsonDict | None:
         return await self.make_request(HttpMethod.PATCH, endpoint, data)
 
-    async def delete(self, endpoint: str) -> dict[str, Any] | None:
+    async def delete(self, endpoint: str) -> JsonDict | None:
         return await self.make_request(HttpMethod.DELETE, endpoint)
 
     async def make_request(
         self,
         method: HttpMethod,
         endpoint: str,
-        data: dict[str, Any] | None = None,
-        params: dict[str, Any] | None = None,
-    ) -> dict[str, Any] | None:
+        data: JsonDict | None = None,
+        params: JsonDict | None = None,
+    ) -> JsonDict | None:
         """
         Executes an HTTP request and returns the data or None on error.
 
@@ -158,7 +158,7 @@ class NotionHttpClient(LoggingMixin):
             )
         if status_code == 404:
             raise NotionResourceNotFoundError(
-                "The requested resource was not found. Please verify the page/database ID.",
+                "The requested resource was not found. Please verify the page/database/datasource ID.",
                 status_code=status_code,
                 response_text=response_text,
             )
@@ -193,7 +193,6 @@ class NotionHttpClient(LoggingMixin):
             None,
         )
         if token:
-            self.logger.debug("Found token in environment variable.")
             return token
         self.logger.warning("No Notion API token found in environment variables")
         return None

notionary/http/models.py

@@ -3,7 +3,8 @@ from __future__ import annotations
 import time
 from dataclasses import dataclass, field
 from enum import StrEnum
-from typing import Any
+
+from notionary.shared.typings import JsonDict
 
 
 class HttpMethod(StrEnum):
@@ -17,8 +18,8 @@ class HttpMethod(StrEnum):
 class HttpRequest:
     method: HttpMethod
     endpoint: str
-    data: dict[str, Any] | None = None
-    params: dict[str, Any] | None = None
+    data: JsonDict | None = None
+    params: JsonDict | None = None
     timestamp: float = field(default_factory=time.time)
     cached_response: HttpResponse | None = None
 
@@ -38,7 +39,7 @@ class HttpRequest:
 
 @dataclass
 class HttpResponse:
-    data: dict[str, Any] | None
+    data: JsonDict | None
     status_code: int = 200
     headers: dict[str, str] = field(default_factory=dict)
     timestamp: float = field(default_factory=time.time)

notionary/page/content/factory.py

@@ -2,11 +2,16 @@ from notionary.blocks.client import NotionBlockHttpClient
 from notionary.page.content.parser.factory import ConverterChainFactory
 from notionary.page.content.parser.post_processing.handlers import RichTextLengthTruncationPostProcessor
 from notionary.page.content.parser.post_processing.service import BlockPostProcessor
-from notionary.page.content.parser.pre_processsing.handlers import ColumnSyntaxPreProcessor, WhitespacePreProcessor
+from notionary.page.content.parser.pre_processsing.handlers import (
+    ColumnSyntaxPreProcessor,
+    IndentationNormalizer,
+    VideoFormatPreProcessor,
+    WhitespacePreProcessor,
+)
 from notionary.page.content.parser.pre_processsing.service import MarkdownPreProcessor
 from notionary.page.content.parser.service import MarkdownToNotionConverter
 from notionary.page.content.renderer.factory import RendererChainFactory
-from notionary.page.content.renderer.post_processing.handlers import NumberedListPlaceholderReplaceerPostProcessor
+from notionary.page.content.renderer.post_processing.handlers import NumberedListPlaceholderReplacerPostProcessor
 from notionary.page.content.renderer.post_processing.service import MarkdownRenderingPostProcessor
 from notionary.page.content.renderer.service import NotionToMarkdownConverter
 from notionary.page.content.service import PageContentService
@@ -55,6 +60,8 @@ class PageContentServiceFactory:
         pre_processor = MarkdownPreProcessor()
         pre_processor.register(ColumnSyntaxPreProcessor())
         pre_processor.register(WhitespacePreProcessor())
+        pre_processor.register(IndentationNormalizer())
+        pre_processor.register(VideoFormatPreProcessor())
         return pre_processor
 
     def _create_post_processor(self) -> BlockPostProcessor:
@@ -64,5 +71,5 @@ class PageContentServiceFactory:
 
     def _create_markdown_rendering_post_processor(self) -> MarkdownRenderingPostProcessor:
         post_processor = MarkdownRenderingPostProcessor()
-        post_processor.register(NumberedListPlaceholderReplaceerPostProcessor())
+        post_processor.register(NumberedListPlaceholderReplacerPostProcessor())
         return post_processor