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

notionary/shared/entity/service.py

@@ -1,12 +1,16 @@
 import random
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from typing import Self
+from pathlib import Path
+from typing import Self, cast
 
-from notionary.shared.entity.entity_metadata_update_client import EntityMetadataUpdateClient
+from notionary.file_upload.service import NotionFileUpload
+from notionary.shared.entity.entity_metadata_update_client import (
+    EntityMetadataUpdateClient,
+)
 from notionary.shared.entity.schemas import EntityResponseDto
-from notionary.shared.models.cover import CoverType
-from notionary.shared.models.icon import IconType
+from notionary.shared.models.file import ExternalFile, FileType, NotionHostedFile
+from notionary.shared.models.icon import EmojiIcon, IconType
 from notionary.shared.models.parent import ParentType
 from notionary.user.base import BaseUser
 from notionary.user.service import UserService
@@ -19,6 +23,7 @@ class Entity(LoggingMixin, ABC):
         self,
         dto: EntityResponseDto,
         user_service: UserService | None = None,
+        file_upload_service: NotionFileUpload | None = None,
     ) -> None:
         self._id = dto.id
         self._created_time = dto.created_time
@@ -35,6 +40,7 @@ class Entity(LoggingMixin, ABC):
         self._cover_image_url = self._extract_cover_image_url(dto)
 
         self._user_service = user_service or UserService()
+        self._file_upload_service = file_upload_service or NotionFileUpload()
 
     @staticmethod
     def _extract_emoji_icon(dto: EntityResponseDto) -> str | None:
@@ -43,25 +49,36 @@ class Entity(LoggingMixin, ABC):
         if dto.icon.type is not IconType.EMOJI:
             return None
 
-        return dto.icon.emoji
+        emoji_icon = cast(EmojiIcon, dto.icon)
+        return emoji_icon.emoji
 
     @staticmethod
     def _extract_external_icon_url(dto: EntityResponseDto) -> str | None:
         if dto.icon is None:
             return None
-        if dto.icon.type is not IconType.EXTERNAL:
-            return None
 
-        return dto.icon.external.url
+        if dto.icon.type == IconType.EXTERNAL:
+            external_icon = cast(ExternalFile, dto.icon)
+            return external_icon.external.url
+        elif dto.icon.type == IconType.FILE:
+            notion_file_icon = cast(NotionHostedFile, dto.icon)
+            return notion_file_icon.file.url
+
+        return None
 
     @staticmethod
     def _extract_cover_image_url(dto: EntityResponseDto) -> str | None:
         if dto.cover is None:
             return None
-        if dto.cover.type is not CoverType.EXTERNAL:
-            return None
 
-        return dto.cover.external.url
+        if dto.cover.type == FileType.EXTERNAL:
+            external_cover = cast(ExternalFile, dto.cover)
+            return external_cover.external.url
+        elif dto.cover.type == FileType.FILE:
+            notion_file_cover = cast(NotionHostedFile, dto.cover)
+            return notion_file_cover.file.url
+
+        return None
 
     @classmethod
     @abstractmethod
@@ -82,10 +99,7 @@ class Entity(LoggingMixin, ABC):
 
     @property
     @abstractmethod
-    def _entity_metadata_update_client(self) -> EntityMetadataUpdateClient:
-        # functionality for updating properties like title, icon, cover, archive status depends on interface for template like implementation
-        # has to be implementated by inheritants to correctly use the methods below
-        ...
+    def _entity_metadata_update_client(self) -> EntityMetadataUpdateClient: ...
 
     @property
     def id(self) -> str:
@@ -123,10 +137,6 @@ class Entity(LoggingMixin, ABC):
     def public_url(self) -> str | None:
         return self._public_url
 
-    # =========================================================================
-    # Parent ID Getters
-    # =========================================================================
-
     def get_parent_database_id_if_present(self) -> str | None:
         if self._parent.type == ParentType.DATABASE_ID:
             return self._parent.database_id
@@ -150,27 +160,48 @@ class Entity(LoggingMixin, ABC):
     def is_workspace_parent(self) -> bool:
         return self._parent.type == ParentType.WORKSPACE
 
-    # =========================================================================
-    # User Methods
-    # =========================================================================
-
     async def get_created_by_user(self) -> BaseUser | None:
         return await self._user_service.get_user_by_id(self._created_by.id)
 
     async def get_last_edited_by_user(self) -> BaseUser | None:
         return await self._user_service.get_user_by_id(self._last_edited_by.id)
 
-    # =========================================================================
-    # Icon & Cover Methods
-    # =========================================================================
-
     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_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)
 
@@ -180,7 +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_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
+            )
+        )
         self._cover_image_url = self._extract_cover_image_url(entity_response)
 
     async def set_random_gradient_cover(self) -> None:
@@ -191,10 +248,6 @@ class Entity(LoggingMixin, ABC):
         await self._entity_metadata_update_client.remove_cover()
         self._cover_image_url = None
 
-    # =========================================================================
-    # Trash Methods
-    # =========================================================================
-
     async def move_to_trash(self) -> None:
         if self._in_trash:
             self.logger.warning("Entity is already in trash.")
@@ -223,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

@@ -1,21 +1,51 @@
 from enum import StrEnum
-from typing import Literal, Self
+from typing import Annotated, Literal, Self
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class FileType(StrEnum):
     EXTERNAL = "external"
+    FILE = "file"
+    FILE_UPLOAD = "file_upload"
 
 
-class ExternalFile(BaseModel):
+class ExternalFileData(BaseModel):
     url: str
 
 
-class ExternalRessource(BaseModel):
+class ExternalFile(BaseModel):
     type: Literal[FileType.EXTERNAL] = FileType.EXTERNAL
-    external: ExternalFile
+    external: ExternalFileData
 
     @classmethod
     def from_url(cls, url: str) -> Self:
-        return cls(external=ExternalFile(url=url))
+        return cls(external=ExternalFileData(url=url))
+
+
+class NotionHostedFileData(BaseModel):
+    url: str
+    expiry_time: str
+
+
+class NotionHostedFile(BaseModel):
+    type: Literal[FileType.FILE] = FileType.FILE
+    file: NotionHostedFileData
+
+
+class FileUploadedFileData(BaseModel):
+    id: str
+
+
+class FileUploadFile(BaseModel):
+    type: Literal[FileType.FILE_UPLOAD] = FileType.FILE_UPLOAD
+    file_upload: FileUploadedFileData
+
+    @classmethod
+    def from_id(cls, id: str) -> Self:
+        return cls(file_upload=FileUploadedFileData(id=id))
+
+
+type File = Annotated[
+    ExternalFile | NotionHostedFile | FileUploadFile, Field(discriminator="type")
+]

notionary/shared/models/icon.py

@@ -1,14 +1,16 @@
 from enum import StrEnum
-from typing import Literal, Self
+from typing import Literal
 
 from pydantic import BaseModel
 
-from notionary.shared.models.file import ExternalFile
+from notionary.shared.models.file import File
 
 
 class IconType(StrEnum):
     EMOJI = "emoji"
     EXTERNAL = "external"
+    FILE = "file"
+    FILE_UPLOAD = "file_upload"
 
 
 class EmojiIcon(BaseModel):
@@ -16,13 +18,4 @@ class EmojiIcon(BaseModel):
     emoji: str
 
 
-class ExternalIcon(BaseModel):
-    type: Literal[IconType.EXTERNAL] = IconType.EXTERNAL
-    external: ExternalFile
-
-    @classmethod
-    def from_url(cls, url: str) -> Self:
-        return cls(external=ExternalFile(url=url))
-
-
-Icon = EmojiIcon | ExternalIcon
+type Icon = EmojiIcon | File

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,9 +23,23 @@ 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
+    def workspace_name(self) -> str | None:
+        return self._workspace_name
+
+    @property
+    def workspace_file_upload_limit_in_bytes(self) -> int:
+        return self._workspace_file_upload_limit_in_bytes
+
+    @property
+    def owner_type(self) -> WorkspaceOwnerType | None:
+        return self._owner_type
+
     @classmethod
     def _get_expected_user_type(cls) -> UserType:
         return UserType.BOT
@@ -54,17 +74,5 @@ class BotUser(BaseUser):
             owner_type=owner_type,
         )
 
-    @property
-    def workspace_name(self) -> str | None:
-        return self._workspace_name
-
-    @property
-    def workspace_file_upload_limit_in_bytes(self) -> int:
-        return self._workspace_file_upload_limit_in_bytes
-
-    @property
-    def owner_type(self) -> WorkspaceOwnerType | None:
-        return self._owner_type
-
     def __repr__(self) -> str:
         return f"BotUser(id={self._id!r}, name={self._name!r}, avatar_url={self._avatar_url!r}, workspace_name={self._workspace_name!r}, workspace_file_upload_limit_in_bytes={self._workspace_file_upload_limit_in_bytes!r}, owner_type={self._owner_type!r})"

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

@@ -9,10 +9,10 @@ P = ParamSpec("P")
 R = TypeVar("R")
 T = TypeVar("T")
 
-type SyncFunc = Callable[P, R]
-type AsyncFunc = Callable[P, Coroutine[Any, Any, R]]
-type SyncDecorator = Callable[[SyncFunc], SyncFunc]
-type AsyncDecorator = Callable[[AsyncFunc], AsyncFunc]
+type _SyncFunc = Callable[P, R]
+type _AsyncFunc = Callable[P, Coroutine[Any, Any, R]]
+type _SyncDecorator = Callable[[_SyncFunc], _SyncFunc]
+type _AsyncDecorator = Callable[[_AsyncFunc], _AsyncFunc]
 
 
 def singleton(cls):
@@ -26,8 +26,10 @@ def singleton(cls):
     return wrapper
 
 
-def time_execution_sync(additional_text: str = "", min_duration_to_log: float = 0.25) -> SyncDecorator:
-    def decorator(func: SyncFunc) -> SyncFunc:
+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:
             start_time = time.perf_counter()
@@ -49,8 +51,8 @@ def time_execution_sync(additional_text: str = "", min_duration_to_log: float =
 def time_execution_async(
     additional_text: str = "",
     min_duration_to_log: float = 0.25,
-) -> AsyncDecorator:
-    def decorator(func: AsyncFunc) -> AsyncFunc:
+) -> _AsyncDecorator:
+    def decorator(func: _AsyncFunc) -> _AsyncFunc:
         @functools.wraps(func)
         async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
             start_time = time.perf_counter()
@@ -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
+from .query import NotionWorkspaceQueryConfigBuilder, WorkspaceQueryConfig
 from .service import NotionWorkspace
 
-__all__ = ["NotionWorkspace", "NotionWorkspaceQueryConfigBuilder"]
+__all__ = [
+    "NotionWorkspace",
+    "NotionWorkspaceQueryConfigBuilder",
+    "WorkspaceQueryConfig",
+]

notionary/workspace/query/__init__.py

@@ -1,3 +1,4 @@
 from .builder import NotionWorkspaceQueryConfigBuilder
+from .models import WorkspaceQueryConfig
 
-__all__ = ["NotionWorkspaceQueryConfigBuilder"]
+__all__ = ["NotionWorkspaceQueryConfigBuilder", "WorkspaceQueryConfig"]