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

notionary/shared/entity/service.py

@@ -5,7 +5,9 @@ from pathlib import Path
 from typing import Self, cast
 
 from notionary.file_upload.service import NotionFileUpload
-from notionary.shared.entity.entity_metadata_update_client import EntityMetadataUpdateClient
+from notionary.shared.entity.entity_metadata_update_client import (
+    EntityMetadataUpdateClient,
+)
 from notionary.shared.entity.schemas import EntityResponseDto
 from notionary.shared.models.file import ExternalFile, FileType, NotionHostedFile
 from notionary.shared.models.icon import EmojiIcon, IconType
@@ -165,25 +167,41 @@ class Entity(LoggingMixin, ABC):
         return await self._user_service.get_user_by_id(self._last_edited_by.id)
 
     async def set_emoji_icon(self, emoji: str) -> None:
-        entity_response = await self._entity_metadata_update_client.patch_emoji_icon(emoji)
+        entity_response = await self._entity_metadata_update_client.patch_emoji_icon(
+            emoji
+        )
         self._emoji_icon = self._extract_emoji_icon(entity_response)
         self._external_icon_url = None
 
     async def set_external_icon(self, icon_url: str) -> None:
-        entity_response = await self._entity_metadata_update_client.patch_external_icon(icon_url)
+        entity_response = await self._entity_metadata_update_client.patch_external_icon(
+            icon_url
+        )
         self._emoji_icon = None
         self._external_icon_url = self._extract_external_icon_url(entity_response)
 
-    async def set_icon_from_file(self, file_path: Path, filename: str | None = None) -> None:
-        upload_response = await self._file_upload_service.upload_file(file_path, filename)
-        await self._set_icon_from_file_upload(upload_response.id)
-
-    async def set_icon_from_bytes(self, file_content: bytes, filename: str, content_type: str | None = None) -> None:
-        upload_response = await self._file_upload_service.upload_from_bytes(file_content, filename, content_type)
-        await self._set_icon_from_file_upload(upload_response.id)
+    async def set_icon_from_file(
+        self, file_path: Path, filename: str | None = None
+    ) -> None:
+        upload_response = await self._file_upload_service.upload_file(
+            file_path, filename
+        )
+        await self.set_icon_from_file_upload(upload_response.id)
 
-    async def _set_icon_from_file_upload(self, file_upload_id: str) -> None:
-        entity_response = await self._entity_metadata_update_client.patch_icon_from_file_upload(file_upload_id)
+    async def set_icon_from_bytes(
+        self, file_content: bytes, filename: str, content_type: str | None = None
+    ) -> None:
+        upload_response = await self._file_upload_service.upload_from_bytes(
+            file_content, filename, content_type
+        )
+        await self.set_icon_from_file_upload(upload_response.id)
+
+    async def set_icon_from_file_upload(self, file_upload_id: str) -> None:
+        entity_response = (
+            await self._entity_metadata_update_client.patch_icon_from_file_upload(
+                file_upload_id
+            )
+        )
         self._emoji_icon = None
         self._external_icon_url = self._extract_external_icon_url(entity_response)
 
@@ -193,21 +211,33 @@ class Entity(LoggingMixin, ABC):
         self._external_icon_url = None
 
     async def set_cover_image_by_url(self, image_url: str) -> None:
-        entity_response = await self._entity_metadata_update_client.patch_external_cover(image_url)
+        entity_response = (
+            await self._entity_metadata_update_client.patch_external_cover(image_url)
+        )
         self._cover_image_url = self._extract_cover_image_url(entity_response)
 
-    async def set_cover_image_from_file(self, file_path: Path, filename: str | None = None) -> None:
-        upload_response = await self._file_upload_service.upload_file(file_path, filename)
-        await self._set_cover_image_from_file_upload(upload_response.id)
+    async def set_cover_image_from_file(
+        self, file_path: Path, filename: str | None = None
+    ) -> None:
+        upload_response = await self._file_upload_service.upload_file(
+            file_path, filename
+        )
+        await self.set_cover_image_from_file_upload(upload_response.id)
 
     async def set_cover_image_from_bytes(
         self, file_content: bytes, filename: str, content_type: str | None = None
     ) -> None:
-        upload_response = await self._file_upload_service.upload_from_bytes(file_content, filename, content_type)
-        await self._set_cover_image_from_file_upload(upload_response.id)
-
-    async def _set_cover_image_from_file_upload(self, file_upload_id: str) -> None:
-        entity_response = await self._entity_metadata_update_client.patch_cover_from_file_upload(file_upload_id)
+        upload_response = await self._file_upload_service.upload_from_bytes(
+            file_content, filename, content_type
+        )
+        await self.set_cover_image_from_file_upload(upload_response.id)
+
+    async def set_cover_image_from_file_upload(self, file_upload_id: str) -> None:
+        entity_response = (
+            await self._entity_metadata_update_client.patch_cover_from_file_upload(
+                file_upload_id
+            )
+        )
         self._cover_image_url = self._extract_cover_image_url(entity_response)
 
     async def set_random_gradient_cover(self) -> None:
@@ -246,7 +276,8 @@ class Entity(LoggingMixin, ABC):
 
     def _get_random_gradient_cover(self) -> str:
         DEFAULT_NOTION_COVERS: Sequence[str] = [
-            f"https://www.notion.so/images/page-cover/gradients_{i}.png" for i in range(1, 10)
+            f"https://www.notion.so/images/page-cover/gradients_{i}.png"
+            for i in range(1, 10)
         ]
 
         return random.choice(DEFAULT_NOTION_COVERS)

notionary/shared/models/file.py

@@ -46,4 +46,6 @@ class FileUploadFile(BaseModel):
         return cls(file_upload=FileUploadedFileData(id=id))
 
 
-type File = Annotated[ExternalFile | NotionHostedFile | FileUploadFile, Field(discriminator="type")]
+type File = Annotated[
+    ExternalFile | NotionHostedFile | FileUploadFile, Field(discriminator="type")
+]

notionary/shared/models/icon.py

@@ -1,9 +1,11 @@
 from enum import StrEnum
-from typing import Literal
+from typing import Annotated, Literal
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
-from notionary.shared.models.file import File
+from notionary.shared.models.file import (
+    File,
+)
 
 
 class IconType(StrEnum):
@@ -18,4 +20,4 @@ class EmojiIcon(BaseModel):
     emoji: str
 
 
-type Icon = EmojiIcon | File
+type Icon = Annotated[EmojiIcon | File, Field(discriminator="type")]

notionary/user/base.py

@@ -54,7 +54,9 @@ class BaseUser:
 
         expected_type = cls._get_expected_user_type()
         if user_dto.type != expected_type:
-            raise ValueError(f"User {user_id} is not a '{expected_type.value}', but '{user_dto.type.value}'")
+            raise ValueError(
+                f"User {user_id} is not a '{expected_type.value}', but '{user_dto.type.value}'"
+            )
 
         return cls.from_dto(user_dto)
 
@@ -105,7 +107,9 @@ class BaseUser:
     async def _get_all_users_of_type(cls, http_client: UserHttpClient) -> list[Self]:
         all_workspace_user_dtos = await http_client.get_all_workspace_users()
         expected_type = cls._get_expected_user_type()
-        filtered_dtos = [dto for dto in all_workspace_user_dtos if dto.type == expected_type]
+        filtered_dtos = [
+            dto for dto in all_workspace_user_dtos if dto.type == expected_type
+        ]
         return [cls.from_dto(dto) for dto in filtered_dtos]
 
     @classmethod

notionary/user/bot.py

@@ -2,7 +2,13 @@ from typing import Self, cast
 
 from notionary.user.base import BaseUser
 from notionary.user.client import UserHttpClient
-from notionary.user.schemas import BotUserDto, BotUserResponseDto, UserResponseDto, UserType, WorkspaceOwnerType
+from notionary.user.schemas import (
+    BotUserDto,
+    BotUserResponseDto,
+    UserResponseDto,
+    UserType,
+    WorkspaceOwnerType,
+)
 
 
 class BotUser(BaseUser):
@@ -17,7 +23,9 @@ class BotUser(BaseUser):
     ) -> None:
         super().__init__(id=id, name=name, avatar_url=avatar_url)
         self._workspace_name = workspace_name
-        self._workspace_file_upload_limit_in_bytes = workspace_file_upload_limit_in_bytes
+        self._workspace_file_upload_limit_in_bytes = (
+            workspace_file_upload_limit_in_bytes
+        )
         self._owner_type = owner_type
 
     @property

notionary/user/client.py

@@ -17,7 +17,9 @@ class UserHttpClient(NotionHttpClient):
         return adapter.validate_python(response)
 
     async def get_all_workspace_users(self) -> list[UserResponseDto]:
-        all_entities = await paginate_notion_api(self._get_workspace_entities, page_size=100)
+        all_entities = await paginate_notion_api(
+            self._get_workspace_entities, page_size=100
+        )
 
         self.logger.info("Fetched %d total workspace users", len(all_entities))
         return all_entities

notionary/user/person.py

@@ -38,4 +38,6 @@ class PersonUser(BaseUser):
         return self._email
 
     def __repr__(self) -> str:
-        return f"PersonUser(id={self._id!r}, name={self._name!r}, email={self._email!r})"
+        return (
+            f"PersonUser(id={self._id!r}, name={self._name!r}, email={self._email!r})"
+        )

notionary/user/schemas.py

@@ -53,7 +53,9 @@ class BotUserResponseDto(NotionUserBase):
     bot: BotUserDto
 
 
-UserResponseDto = Annotated[PersonUserResponseDto | BotUserResponseDto, Field(discriminator="type")]
+UserResponseDto = Annotated[
+    PersonUserResponseDto | BotUserResponseDto, Field(discriminator="type")
+]
 
 
 class NotionUsersListResponse(BaseModel):

notionary/user/service.py

@@ -42,14 +42,18 @@ class UserService:
         return [
             user
             for user in all_person_users
-            if query_lower in (user.name or "").lower() or query_lower in (user.email or "").lower()
+            if query_lower in (user.name or "").lower()
+            or query_lower in (user.email or "").lower()
         ]
 
     async def search_users_stream(self, query: str) -> AsyncIterator[PersonUser]:
         query_lower = query.lower()
 
         async for user in self.list_users_stream():
-            if query_lower in (user.name or "").lower() or query_lower in (user.email or "").lower():
+            if (
+                query_lower in (user.name or "").lower()
+                or query_lower in (user.email or "").lower()
+            ):
                 yield user
 
     async def get_current_bot(self) -> BotUser:

notionary/utils/decorators.py

@@ -26,7 +26,9 @@ def singleton(cls):
     return wrapper
 
 
-def time_execution_sync(additional_text: str = "", min_duration_to_log: float = 0.25) -> _SyncDecorator:
+def time_execution_sync(
+    additional_text: str = "", min_duration_to_log: float = 0.25
+) -> _SyncDecorator:
     def decorator(func: _SyncFunc) -> _SyncFunc:
         @functools.wraps(func)
         def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
@@ -106,7 +108,9 @@ def async_retry(
                 except Exception as e:
                     last_exception = e
 
-                    if retry_on_exceptions is not None and not isinstance(e, retry_on_exceptions):
+                    if retry_on_exceptions is not None and not isinstance(
+                        e, retry_on_exceptions
+                    ):
                         raise
 
                     if attempt == max_retries:

notionary/utils/fuzzy.py

@@ -28,7 +28,9 @@ def find_all_matches(
     text_extractor: Callable[[T], str],
     min_similarity: float,
 ) -> list[T]:
-    matches = _find_best_matches(query, items, text_extractor, min_similarity, limit=None)
+    matches = _find_best_matches(
+        query, items, text_extractor, min_similarity, limit=None
+    )
     return [match.item for match in matches]
 
 
@@ -56,7 +58,9 @@ def _find_best_matches(
     return results
 
 
-def _sort_by_highest_similarity_first(results: list[_MatchResult]) -> list[_MatchResult]:
+def _sort_by_highest_similarity_first(
+    results: list[_MatchResult],
+) -> list[_MatchResult]:
     return sorted(results, key=lambda x: x.similarity, reverse=True)
 
 

notionary/utils/mixins/logging.py

@@ -19,7 +19,9 @@ def configure_library_logging(level: str = "WARNING") -> None:
         library_logger.handlers.clear()
 
     handler = logging.StreamHandler()
-    handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
+    handler.setFormatter(
+        logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    )
 
     library_logger.setLevel(log_level)
     library_logger.addHandler(handler)

notionary/utils/pagination.py

@@ -24,7 +24,9 @@ async def _fetch_data(
         request_params = _build_request_params(kwargs, next_cursor)
         response = await api_call(**request_params)
 
-        limited_results = _apply_result_limit(response.results, total_results_limit, total_fetched)
+        limited_results = _apply_result_limit(
+            response.results, total_results_limit, total_fetched
+        )
         total_fetched += len(limited_results)
 
         yield _create_limited_response(response, limited_results, api_page_size)
@@ -52,7 +54,9 @@ def _build_request_params(
     return params
 
 
-def _apply_result_limit(results: list[Any], total_limit: int | None, total_fetched: int) -> list[Any]:
+def _apply_result_limit(
+    results: list[Any], total_limit: int | None, total_fetched: int
+) -> list[Any]:
     if total_limit is None:
         return results
 
@@ -74,7 +78,11 @@ def _create_limited_response(
     results_were_limited_by_client = len(limited_results) < len(original.results)
     api_returned_full_page = len(original.results) == api_page_size
 
-    has_more_after_limit = original.has_more and not results_were_limited_by_client and api_returned_full_page
+    has_more_after_limit = (
+        original.has_more
+        and not results_were_limited_by_client
+        and api_returned_full_page
+    )
 
     return PaginatedResponse(
         results=limited_results,
@@ -89,7 +97,9 @@ async def paginate_notion_api(
     **kwargs,
 ) -> list[Any]:
     all_results = []
-    async for page in _fetch_data(api_call, total_results_limit=total_results_limit, **kwargs):
+    async for page in _fetch_data(
+        api_call, total_results_limit=total_results_limit, **kwargs
+    ):
         all_results.extend(page.results)
     return all_results
 

notionary/workspace/__init__.py

@@ -1,4 +1,8 @@
 from .query import NotionWorkspaceQueryConfigBuilder, WorkspaceQueryConfig
 from .service import NotionWorkspace
 
-__all__ = ["NotionWorkspace", "NotionWorkspaceQueryConfigBuilder", "WorkspaceQueryConfig"]
+__all__ = [
+    "NotionWorkspace",
+    "NotionWorkspaceQueryConfigBuilder",
+    "WorkspaceQueryConfig",
+]

notionary/workspace/query/service.py

@@ -4,7 +4,11 @@ import asyncio
 from collections.abc import AsyncIterator
 from typing import TYPE_CHECKING
 
-from notionary.exceptions.search import DatabaseNotFound, DataSourceNotFound, PageNotFound
+from notionary.exceptions.search import (
+    DatabaseNotFound,
+    DataSourceNotFound,
+    PageNotFound,
+)
 from notionary.utils.fuzzy import find_all_matches
 from notionary.workspace.client import WorkspaceClient
 from notionary.workspace.query.builder import NotionWorkspaceQueryConfigBuilder
@@ -18,7 +22,9 @@ class WorkspaceQueryService:
     def __init__(self, client: WorkspaceClient | None = None) -> None:
         self._client = client or WorkspaceClient()
 
-    async def get_pages_stream(self, search_config: WorkspaceQueryConfig) -> AsyncIterator[NotionPage]:
+    async def get_pages_stream(
+        self, search_config: WorkspaceQueryConfig
+    ) -> AsyncIterator[NotionPage]:
         from notionary import NotionPage
 
         async for page_dto in self._client.query_pages_stream(search_config):
@@ -27,48 +33,81 @@ class WorkspaceQueryService:
     async def get_pages(self, search_config: WorkspaceQueryConfig) -> list[NotionPage]:
         from notionary import NotionPage
 
-        page_dtos = [dto async for dto in self._client.query_pages_stream(search_config)]
+        page_dtos = [
+            dto async for dto in self._client.query_pages_stream(search_config)
+        ]
         page_tasks = [NotionPage.from_id(dto.id) for dto in page_dtos]
         return await asyncio.gather(*page_tasks)
 
-    async def get_data_sources_stream(self, search_config: WorkspaceQueryConfig) -> AsyncIterator[NotionDataSource]:
+    async def get_data_sources_stream(
+        self, search_config: WorkspaceQueryConfig
+    ) -> AsyncIterator[NotionDataSource]:
         from notionary import NotionDataSource
 
-        async for data_source_dto in self._client.query_data_sources_stream(search_config):
+        async for data_source_dto in self._client.query_data_sources_stream(
+            search_config
+        ):
             yield await NotionDataSource.from_id(data_source_dto.id)
 
-    async def get_data_sources(self, search_config: WorkspaceQueryConfig) -> list[NotionDataSource]:
+    async def get_data_sources(
+        self, search_config: WorkspaceQueryConfig
+    ) -> list[NotionDataSource]:
         from notionary import NotionDataSource
 
-        data_source_dtos = [dto async for dto in self._client.query_data_sources_stream(search_config)]
-        data_source_tasks = [NotionDataSource.from_id(dto.id) for dto in data_source_dtos]
+        data_source_dtos = [
+            dto async for dto in self._client.query_data_sources_stream(search_config)
+        ]
+        data_source_tasks = [
+            NotionDataSource.from_id(dto.id) for dto in data_source_dtos
+        ]
         return await asyncio.gather(*data_source_tasks)
 
     async def find_data_source(self, query: str) -> NotionDataSource:
         config = (
-            NotionWorkspaceQueryConfigBuilder().with_query(query).with_data_sources_only().with_page_size(100).build()
+            NotionWorkspaceQueryConfigBuilder()
+            .with_query(query)
+            .with_data_sources_only()
+            .with_page_size(100)
+            .build()
         )
         data_sources = await self.get_data_sources(config)
         return self._find_exact_match(data_sources, query, DataSourceNotFound)
 
     async def find_page(self, query: str) -> NotionPage:
-        config = NotionWorkspaceQueryConfigBuilder().with_query(query).with_pages_only().with_page_size(100).build()
+        config = (
+            NotionWorkspaceQueryConfigBuilder()
+            .with_query(query)
+            .with_pages_only()
+            .with_page_size(100)
+            .build()
+        )
         pages = await self.get_pages(config)
         return self._find_exact_match(pages, query, PageNotFound)
 
     async def find_database(self, query: str) -> NotionDatabase:
         config = (
-            NotionWorkspaceQueryConfigBuilder().with_query(query).with_data_sources_only().with_page_size(100).build()
+            NotionWorkspaceQueryConfigBuilder()
+            .with_query(query)
+            .with_data_sources_only()
+            .with_page_size(100)
+            .build()
         )
         data_sources = await self.get_data_sources(config)
 
-        parent_database_ids = [data_sources.get_parent_database_id_if_present() for data_sources in data_sources]
+        parent_database_ids = [
+            data_sources.get_parent_database_id_if_present()
+            for data_sources in data_sources
+        ]
         # filter none values which should not happen but for safety
         parent_database_ids = [id for id in parent_database_ids if id is not None]
 
-        parent_database_tasks = [NotionDatabase.from_id(db_id) for db_id in parent_database_ids]
+        parent_database_tasks = [
+            NotionDatabase.from_id(db_id) for db_id in parent_database_ids
+        ]
         parent_databases = await asyncio.gather(*parent_database_tasks)
-        potential_databases = [database for database in parent_databases if database is not None]
+        potential_databases = [
+            database for database in parent_databases if database is not None
+        ]
 
         return self._find_exact_match(potential_databases, query, DatabaseNotFound)
 
@@ -82,7 +121,9 @@ class WorkspaceQueryService:
             raise exception_class(query, [])
 
         query_lower = query.lower()
-        exact_matches = [result for result in search_results if result.title.lower() == query_lower]
+        exact_matches = [
+            result for result in search_results if result.title.lower() == query_lower
+        ]
 
         if exact_matches:
             return exact_matches[0]
@@ -90,7 +131,9 @@ class WorkspaceQueryService:
         suggestions = self._get_fuzzy_suggestions(search_results, query)
         raise exception_class(query, suggestions)
 
-    def _get_fuzzy_suggestions(self, search_results: list[SearchableEntity], query: str) -> list[str]:
+    def _get_fuzzy_suggestions(
+        self, search_results: list[SearchableEntity], query: str
+    ) -> list[str]:
         sorted_by_similarity = find_all_matches(
             query=query,
             items=search_results,

notionary/workspace/service.py

@@ -5,7 +5,10 @@ from typing import TYPE_CHECKING, Self
 
 from notionary.user.service import UserService
 from notionary.workspace.query.builder import NotionWorkspaceQueryConfigBuilder
-from notionary.workspace.query.models import WorkspaceQueryConfig, WorkspaceQueryObjectType
+from notionary.workspace.query.models import (
+    WorkspaceQueryConfig,
+    WorkspaceQueryObjectType,
+)
 from notionary.workspace.query.service import WorkspaceQueryService
 
 if TYPE_CHECKING:
@@ -39,56 +42,81 @@ class NotionWorkspace:
     async def get_pages(
         self,
         *,
-        filter_fn: Callable[[NotionWorkspaceQueryConfigBuilder], NotionWorkspaceQueryConfigBuilder] | None = None,
+        filter_fn: Callable[
+            [NotionWorkspaceQueryConfigBuilder], NotionWorkspaceQueryConfigBuilder
+        ]
+        | None = None,
         query_config: WorkspaceQueryConfig | None = None,
     ) -> list[NotionPage]:
         if filter_fn is not None and query_config is not None:
             raise ValueError("Use either filter_fn OR query_config, not both")
 
-        resolved_config = self._resolve_query_config(filter_fn, query_config, WorkspaceQueryObjectType.PAGE)
+        resolved_config = self._resolve_query_config(
+            filter_fn, query_config, WorkspaceQueryObjectType.PAGE
+        )
         return await self._query_service.get_pages(resolved_config)
 
     async def get_pages_stream(
         self,
         *,
-        filter_fn: Callable[[NotionWorkspaceQueryConfigBuilder], NotionWorkspaceQueryConfigBuilder] | None = None,
+        filter_fn: Callable[
+            [NotionWorkspaceQueryConfigBuilder], NotionWorkspaceQueryConfigBuilder
+        ]
+        | None = None,
         query_config: WorkspaceQueryConfig | None = None,
     ) -> AsyncIterator[NotionPage]:
         if filter_fn is not None and query_config is not None:
             raise ValueError("Use either filter_fn OR query_config, not both")
 
-        resolved_config = self._resolve_query_config(filter_fn, query_config, WorkspaceQueryObjectType.PAGE)
+        resolved_config = self._resolve_query_config(
+            filter_fn, query_config, WorkspaceQueryObjectType.PAGE
+        )
         async for page in self._query_service.get_pages_stream(resolved_config):
             yield page
 
     async def get_data_sources(
         self,
         *,
-        filter_fn: Callable[[NotionWorkspaceQueryConfigBuilder], NotionWorkspaceQueryConfigBuilder] | None = None,
+        filter_fn: Callable[
+            [NotionWorkspaceQueryConfigBuilder], NotionWorkspaceQueryConfigBuilder
+        ]
+        | None = None,
         query_config: WorkspaceQueryConfig | None = None,
     ) -> list[NotionDataSource]:
         if filter_fn is not None and query_config is not None:
             raise ValueError("Use either filter_fn OR query_config, not both")
 
-        resolved_config = self._resolve_query_config(filter_fn, query_config, WorkspaceQueryObjectType.DATA_SOURCE)
+        resolved_config = self._resolve_query_config(
+            filter_fn, query_config, WorkspaceQueryObjectType.DATA_SOURCE
+        )
         return await self._query_service.get_data_sources(resolved_config)
 
     async def get_data_sources_stream(
         self,
         *,
-        filter_fn: Callable[[NotionWorkspaceQueryConfigBuilder], NotionWorkspaceQueryConfigBuilder] | None = None,
+        filter_fn: Callable[
+            [NotionWorkspaceQueryConfigBuilder], NotionWorkspaceQueryConfigBuilder
+        ]
+        | None = None,
         query_config: WorkspaceQueryConfig | None = None,
     ) -> AsyncIterator[NotionDataSource]:
         if filter_fn is not None and query_config is not None:
             raise ValueError("Use either filter_fn OR query_config, not both")
 
-        resolved_config = self._resolve_query_config(filter_fn, query_config, WorkspaceQueryObjectType.DATA_SOURCE)
-        async for data_source in self._query_service.get_data_sources_stream(resolved_config):
+        resolved_config = self._resolve_query_config(
+            filter_fn, query_config, WorkspaceQueryObjectType.DATA_SOURCE
+        )
+        async for data_source in self._query_service.get_data_sources_stream(
+            resolved_config
+        ):
             yield data_source
 
     def _resolve_query_config(
         self,
-        filter_fn: Callable[[NotionWorkspaceQueryConfigBuilder], NotionWorkspaceQueryConfigBuilder] | None,
+        filter_fn: Callable[
+            [NotionWorkspaceQueryConfigBuilder], NotionWorkspaceQueryConfigBuilder
+        ]
+        | None,
         query_config: WorkspaceQueryConfig | None,
         expected_object_type: WorkspaceQueryObjectType,
     ) -> WorkspaceQueryConfig:

{notionary-0.4.0.dist-info → notionary-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionary
-Version: 0.4.0
+Version: 0.4.2
 Summary: Python library for programmatic Notion workspace management - databases, pages, and content with advanced Markdown support
 Project-URL: Homepage, https://github.com/mathisarends/notionary
 Author-email: Mathis Arends <mathisarends27@gmail.com>