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

notionary/data_source/schemas.py

@@ -1,7 +1,7 @@
 from pydantic import BaseModel
 
 from notionary.blocks.rich_text.models import RichText
-from notionary.data_source.properties.schemas import DiscriminatedDataSourceProperty
+from notionary.data_source.properties.schemas import AnyDataSourceProperty
 from notionary.page.schemas import NotionPageDto
 from notionary.shared.entity.schemas import EntityResponseDto, NotionEntityUpdateDto
 from notionary.shared.models.parent import Parent
@@ -24,4 +24,4 @@ class DataSourceDto(EntityResponseDto):
     title: list[RichText]
     description: list[RichText]
     archived: bool
-    properties: dict[str, DiscriminatedDataSourceProperty]
+    properties: dict[str, AnyDataSourceProperty]

notionary/data_source/service.py

@@ -20,7 +20,8 @@ from notionary.data_source.query import DataSourceQueryBuilder, DataSourceQueryP
 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.file_upload.service import NotionFileUpload
+from notionary.page.properties.schemas import PageTitleProperty
 from notionary.page.schemas import NotionPageDto
 from notionary.shared.entity.dto_parsers import (
     extract_description,
@@ -28,6 +29,7 @@ from notionary.shared.entity.dto_parsers import (
 )
 from notionary.shared.entity.entity_metadata_update_client import EntityMetadataUpdateClient
 from notionary.shared.entity.service import Entity
+from notionary.user.service import UserService
 from notionary.workspace.query.service import WorkspaceQueryService
 
 if TYPE_CHECKING:
@@ -43,8 +45,10 @@ class NotionDataSource(Entity):
         properties: dict[str, DataSourceProperty],
         data_source_instance_client: DataSourceInstanceClient,
         query_resolver: QueryResolver | None = None,
+        user_service: UserService | None = None,
+        file_upload_service: NotionFileUpload | None = None,
     ) -> None:
-        super().__init__(dto=dto)
+        super().__init__(dto=dto, user_service=user_service, file_upload_service=file_upload_service)
 
         self._parent_database: NotionDatabase | None = None
         self._title = title
@@ -116,6 +120,10 @@ class NotionDataSource(Entity):
     def properties(self) -> dict[str, DataSourceProperty]:
         return self._properties
 
+    @property
+    def data_source_query_builder(self) -> DataSourceQueryBuilder:
+        return DataSourceQueryBuilder(properties=self._properties)
+
     async def create_blank_page(self, title: str | None = None) -> NotionPage:
         return await self._data_source_client.create_blank_page(title=title)
 
@@ -222,44 +230,45 @@ class NotionDataSource(Entity):
 
         return prop
 
-    def filter(self) -> DataSourceQueryBuilder:
+    def get_query_builder(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,
+        *,
+        filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder] | None = None,
         query_params: DataSourceQueryParams | None = None,
     ) -> list[NotionPage]:
         from notionary import NotionPage
 
+        if filter_fn is not None and query_params is not None:
+            raise ValueError("Use either filter_fn OR query_params, not both")
+
+        if filter_fn is not None:
+            builder = DataSourceQueryBuilder(properties=self._properties)
+            configured_builder = filter_fn(builder)
+            query_params = configured_builder.build()
+
         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(
+    async def iter_pages(
         self,
+        *,
+        filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder] | None = None,
         query_params: DataSourceQueryParams | None = None,
     ) -> AsyncIterator[NotionPage]:
         from notionary import NotionPage
 
+        if filter_fn is not None and query_params is not None:
+            raise ValueError("Use either filter_fn OR query_params, not both")
+
+        if filter_fn is not None:
+            builder = DataSourceQueryBuilder(properties=self._properties)
+            configured_builder = filter_fn(builder)
+            query_params = configured_builder.build()
+
         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):

notionary/database/schemas.py

@@ -2,7 +2,7 @@ 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.file import File
 from notionary.shared.models.icon import Icon
 
 
@@ -24,6 +24,6 @@ class NotionDatabaseDto(EntityResponseDto):
 class NotionDatabaseUpdateDto(BaseModel):
     title: list[RichText] | None = None
     icon: Icon | None = None
-    cover: NotionCover | None = None
+    cover: File | None = None
     archived: bool | None = None
     description: list[RichText] | None = None

notionary/database/service.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import asyncio
 from collections.abc import Awaitable, Callable
 from typing import Self
@@ -16,7 +14,7 @@ from notionary.shared.entity.dto_parsers import (
 from notionary.shared.entity.service import Entity
 from notionary.workspace.query.service import WorkspaceQueryService
 
-type DataSourceFactory = Callable[[str], Awaitable[NotionDataSource]]
+type _DataSourceFactory = Callable[[str], Awaitable[NotionDataSource]]
 
 
 class NotionDatabase(Entity):
@@ -104,7 +102,7 @@ class NotionDatabase(Entity):
 
     async def get_data_sources(
         self,
-        data_source_factory: DataSourceFactory = NotionDataSource.from_id,
+        data_source_factory: _DataSourceFactory = NotionDataSource.from_id,
     ) -> list[NotionDataSource]:
         if self._data_sources is None:
             self._data_sources = await self._load_data_sources(data_source_factory)
@@ -112,7 +110,7 @@ class NotionDatabase(Entity):
 
     async def _load_data_sources(
         self,
-        data_source_factory: DataSourceFactory,
+        data_source_factory: _DataSourceFactory,
     ) -> list[NotionDataSource]:
         tasks = [data_source_factory(ds_id) for ds_id in self._data_source_ids]
         return list(await asyncio.gather(*tasks))

notionary/exceptions/__init__.py

@@ -7,9 +7,10 @@ from .api import (
     NotionServerError,
     NotionValidationError,
 )
-from .base import NotionaryError
+from .base import NotionaryException
 from .block_parsing import InsufficientColumnsError, InvalidColumnRatioSumError, UnsupportedVideoFormatError
 from .data_source import DataSourcePropertyNotFound, DataSourcePropertyTypeError
+from .file_upload import FileSizeException, NoFileExtensionException, UnsupportedFileTypeException
 from .properties import AccessPagePropertyWithoutDataSourceError, PagePropertyNotFoundError, PagePropertyTypeError
 from .search import DatabaseNotFound, DataSourceNotFound, EntityNotFound, PageNotFound
 
@@ -20,8 +21,10 @@ __all__ = [
     "DataSourcePropertyTypeError",
     "DatabaseNotFound",
     "EntityNotFound",
+    "FileSizeException",
     "InsufficientColumnsError",
     "InvalidColumnRatioSumError",
+    "NoFileExtensionException",
     "NotionApiError",
     "NotionAuthenticationError",
     "NotionConnectionError",
@@ -29,9 +32,10 @@ __all__ = [
     "NotionResourceNotFoundError",
     "NotionServerError",
     "NotionValidationError",
-    "NotionaryError",
+    "NotionaryException",
     "PageNotFound",
     "PagePropertyNotFoundError",
     "PagePropertyTypeError",
+    "UnsupportedFileTypeException",
     "UnsupportedVideoFormatError",
 ]

notionary/exceptions/api.py

@@ -1,7 +1,7 @@
-from notionary.exceptions.base import NotionaryError
+from notionary.exceptions.base import NotionaryException
 
 
-class NotionApiError(NotionaryError):
+class NotionApiError(NotionaryException):
     def __init__(
         self,
         message: str,

notionary/exceptions/base.py

@@ -1,2 +1,2 @@
-class NotionaryError(Exception):
+class NotionaryException(Exception):
     pass

notionary/exceptions/block_parsing.py

@@ -1,15 +1,15 @@
-from notionary.exceptions.base import NotionaryError
+from notionary.exceptions.base import NotionaryException
 
 RATIO_TOLERANCE = 0.0001
 
 
-class InsufficientColumnsError(NotionaryError):
+class InsufficientColumnsError(NotionaryException):
     def __init__(self, column_count: int) -> None:
         self.column_count = column_count
         super().__init__(f"Columns container must contain at least 2 column blocks, but only {column_count} found")
 
 
-class InvalidColumnRatioSumError(NotionaryError):
+class InvalidColumnRatioSumError(NotionaryException):
     def __init__(self, total: float, tolerance: float = RATIO_TOLERANCE) -> None:
         self.total = total
         self.tolerance = tolerance

notionary/exceptions/data_source/builder.py

@@ -8,11 +8,11 @@ from notionary.data_source.query.schema import (
     Operator,
     StringOperator,
 )
-from notionary.exceptions.base import NotionaryError
+from notionary.exceptions.base import NotionaryException
 from notionary.shared.properties.type import PropertyType
 
 
-class QueryBuilderError(NotionaryError):
+class QueryBuilderError(NotionaryException):
     def __init__(self, message: str, property_name: str | None = None) -> None:
         self.property_name = property_name
         super().__init__(message)

notionary/exceptions/data_source/properties.py

@@ -1,9 +1,9 @@
 import difflib
 
-from notionary.exceptions.base import NotionaryError
+from notionary.exceptions.base import NotionaryException
 
 
-class DataSourcePropertyNotFound(NotionaryError):
+class DataSourcePropertyNotFound(NotionaryException):
     def __init__(
         self,
         property_name: str,
@@ -28,7 +28,7 @@ class DataSourcePropertyNotFound(NotionaryError):
         super().__init__(message)
 
 
-class DataSourcePropertyTypeError(NotionaryError):
+class DataSourcePropertyTypeError(NotionaryException):
     def __init__(self, property_name: str, expected_type: str, actual_type: str) -> None:
         message = f"Property '{property_name}' has the wrong type. Expected: '{expected_type}', found: '{actual_type}'."
         super().__init__(message)

notionary/exceptions/file_upload.py

@@ -0,0 +1,67 @@
+from notionary.exceptions.base import NotionaryException
+
+
+class UnsupportedFileTypeException(NotionaryException):
+    def __init__(self, extension: str, filename: str, supported_extensions_by_category: dict[str, list[str]]):
+        supported_exts = []
+        for category, extensions in supported_extensions_by_category.items():
+            supported_exts.append(f"{category}: {', '.join(extensions[:5])}...")
+
+        supported_info = "\n  ".join(supported_exts)
+        super().__init__(
+            f"File '{filename}' has unsupported extension '{extension}'.\n"
+            f"Supported file types by category:\n  {supported_info}"
+        )
+        self.extension = extension
+        self.filename = filename
+
+
+class NoFileExtensionException(NotionaryException):
+    def __init__(self, filename: str):
+        super().__init__(
+            f"File '{filename}' has no extension. Files must have a valid extension to determine their type."
+        )
+        self.filename = filename
+
+
+class FileSizeException(NotionaryException):
+    def __init__(self, filename: str, file_size_bytes: int, max_size_bytes: int):
+        file_size_mb = file_size_bytes / (1024 * 1024)
+        max_size_mb = max_size_bytes / (1024 * 1024)
+        super().__init__(
+            f"File '{filename}' is too large ({file_size_mb:.2f} MB). Maximum allowed size is {max_size_mb:.2f} MB."
+        )
+        self.filename = filename
+        self.file_size_bytes = file_size_bytes
+        self.max_size_bytes = max_size_bytes
+
+
+class FileNotFoundError(NotionaryException):
+    def __init__(self, file_path: str):
+        super().__init__(f"File does not exist: {file_path}")
+        self.file_path = file_path
+
+
+class FilenameTooLongError(NotionaryException):
+    def __init__(self, filename: str, filename_bytes: int, max_filename_bytes: int):
+        super().__init__(f"Filename too long: {filename_bytes} bytes (max {max_filename_bytes}). Filename: {filename}")
+        self.filename = filename
+        self.filename_bytes = filename_bytes
+        self.max_filename_bytes = max_filename_bytes
+
+
+class UploadFailedError(NotionaryException):
+    def __init__(self, file_upload_id: str, reason: str | None = None):
+        message = f"Upload failed for file_upload_id: {file_upload_id}"
+        if reason:
+            message += f". Reason: {reason}"
+        super().__init__(message)
+        self.file_upload_id = file_upload_id
+        self.reason = reason
+
+
+class UploadTimeoutError(NotionaryException):
+    def __init__(self, file_upload_id: str, timeout_seconds: int):
+        super().__init__(f"Upload timeout after {timeout_seconds}s for file_upload_id: {file_upload_id}")
+        self.file_upload_id = file_upload_id
+        self.timeout_seconds = timeout_seconds

notionary/exceptions/properties.py

@@ -1,11 +1,11 @@
 import difflib
 from typing import ClassVar
 
-from notionary.exceptions.base import NotionaryError
+from notionary.exceptions.base import NotionaryException
 from notionary.shared.models.parent import ParentType
 
 
-class PagePropertyNotFoundError(NotionaryError):
+class PagePropertyNotFoundError(NotionaryException):
     def __init__(
         self,
         page_url: str,
@@ -31,7 +31,7 @@ class PagePropertyNotFoundError(NotionaryError):
         super().__init__(message)
 
 
-class PagePropertyTypeError(NotionaryError):
+class PagePropertyTypeError(NotionaryException):
     def __init__(
         self,
         property_name: str,
@@ -41,7 +41,7 @@ class PagePropertyTypeError(NotionaryError):
         super().__init__(message)
 
 
-class AccessPagePropertyWithoutDataSourceError(NotionaryError):
+class AccessPagePropertyWithoutDataSourceError(NotionaryException):
     _PARENT_DESCRIPTIONS: ClassVar[dict[ParentType, str]] = {
         ParentType.WORKSPACE: "the workspace itself",
         ParentType.PAGE_ID: "another page",

notionary/exceptions/search.py

@@ -1,7 +1,7 @@
-from notionary.exceptions.base import NotionaryError
+from notionary.exceptions.base import NotionaryException
 
 
-class EntityNotFound(NotionaryError):
+class EntityNotFound(NotionaryException):
     def __init__(self, entity_type: str, query: str, available_titles: list[str] | None = None) -> None:
         self.entity_type = entity_type
         self.query = query
@@ -33,14 +33,14 @@ class DatabaseNotFound(EntityNotFound):
         super().__init__("database", query, available_titles)
 
 
-class NoUsersInWorkspace(NotionaryError):
+class NoUsersInWorkspace(NotionaryException):
     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):
+class UserNotFound(NotionaryException):
     def __init__(self, user_type: str, query: str, available_names: list[str] | None = None) -> None:
         self.user_type = user_type
         self.query = query

notionary/file_upload/__init__.py

@@ -0,0 +1,4 @@
+from .query import FileUploadQuery, FileUploadQueryBuilder
+from .service import NotionFileUpload
+
+__all__ = ["FileUploadQuery", "FileUploadQueryBuilder", "NotionFileUpload"]