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

notionary/page/content/parser/pre_processsing/handlers/video_syntax.py

@@ -0,0 +1,66 @@
+import re
+from typing import override
+from urllib.parse import urlparse
+
+from notionary.blocks.enums import VideoFileType
+from notionary.exceptions import UnsupportedVideoFormatError
+from notionary.page.content.parser.pre_processsing.handlers.port import PreProcessor
+from notionary.page.content.syntax import SyntaxRegistry
+from notionary.utils.decorators import time_execution_sync
+from notionary.utils.mixins.logging import LoggingMixin
+
+
+class VideoFormatPreProcessor(PreProcessor, LoggingMixin):
+    YOUTUBE_WATCH_PATTERN = re.compile(r"^https?://(?:www\.)?youtube\.com/watch\?.*v=[\w-]+", re.IGNORECASE)
+    YOUTUBE_EMBED_PATTERN = re.compile(r"^https?://(?:www\.)?youtube\.com/embed/[\w-]+", re.IGNORECASE)
+
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__()
+        self._syntax_registry = syntax_registry or SyntaxRegistry()
+        self._video_syntax = self._syntax_registry.get_video_syntax()
+
+    @override
+    @time_execution_sync()
+    def process(self, markdown_text: str) -> str:
+        lines = markdown_text.split("\n")
+        validated_lines = [self._validate_or_reject_line(line) for line in lines]
+        return "\n".join(validated_lines)
+
+    def _validate_or_reject_line(self, line: str) -> str:
+        if not self._contains_video_block(line):
+            return line
+
+        url = self._extract_url_from_video_block(line)
+
+        if self._is_supported_video_url(url):
+            return line
+
+        supported_formats = list(VideoFileType.get_all_extensions())
+        raise UnsupportedVideoFormatError(url, supported_formats)
+
+    def _contains_video_block(self, line: str) -> bool:
+        return self._video_syntax.regex_pattern.search(line) is not None
+
+    def _extract_url_from_video_block(self, line: str) -> str:
+        match = self._video_syntax.regex_pattern.search(line)
+        return match.group(1).strip() if match else ""
+
+    def _is_supported_video_url(self, url: str) -> bool:
+        return (
+            self._is_youtube_video(url)
+            or self._has_valid_video_extension(url)
+            or self._url_path_has_valid_extension(url)
+        )
+
+    def _is_youtube_video(self, url: str) -> bool:
+        return bool(self.YOUTUBE_WATCH_PATTERN.match(url) or self.YOUTUBE_EMBED_PATTERN.match(url))
+
+    def _has_valid_video_extension(self, url: str) -> bool:
+        return VideoFileType.is_valid_extension(url)
+
+    def _url_path_has_valid_extension(self, url: str) -> bool:
+        try:
+            parsed_url = urlparse(url)
+            return VideoFileType.is_valid_extension(parsed_url.path.lower())
+        except Exception:
+            return False

notionary/page/content/parser/pre_processsing/handlers/whitespace.py

@@ -1,10 +1,12 @@
 from typing import override
 
 from notionary.page.content.parser.pre_processsing.handlers.port import PreProcessor
+from notionary.utils.decorators import time_execution_sync
 
 
 class WhitespacePreProcessor(PreProcessor):
     @override
+    @time_execution_sync()
     def process(self, markdown_text: str) -> str:
         if not markdown_text:
             return ""

notionary/page/properties/client.py

@@ -51,8 +51,8 @@ class PagePropertyHttpClient(NotionHttpClient):
 
         return await self.patch_page(update_dto)
 
-    async def patch_title(self, title: str) -> NotionPageDto:
-        return await self._patch_property("title", title, PageTitleProperty)
+    async def patch_title(self, property_name: str, title: str) -> NotionPageDto:
+        return await self._patch_property(property_name, title, PageTitleProperty)
 
     async def patch_rich_text_property(self, property_name: str, text: str) -> NotionPageDto:
         return await self._patch_property(property_name, text, PageRichTextProperty)

notionary/page/properties/service.py

@@ -147,11 +147,22 @@ class PagePropertyHandler:
     # Writer Methods
     # =========================================================================
 
-    async def set_title_property(self, property_name: str, title: str) -> None:
-        self._get_typed_property_or_raise(property_name, PageTitleProperty)
-        updated_page = await self._property_http_client.patch_title(property_name, title)
+    async def set_title_property(self, title: str) -> None:
+        title_property_name = self._extract_title_property_name()
+
+        self._get_typed_property_or_raise(title_property_name, PageTitleProperty)
+        updated_page = await self._property_http_client.patch_title(title_property_name, title)
         self._properties = updated_page.properties
 
+    def _extract_title_property_name(self) -> str | None:
+        if not self._properties:
+            return None
+
+        return next(
+            (key for key, prop in self._properties.items() if isinstance(prop, PageTitleProperty)),
+            None,
+        )
+
     async def set_rich_text_property(self, property_name: str, text: str) -> None:
         self._get_typed_property_or_raise(property_name, PageRichTextProperty)
         updated_page = await self._property_http_client.patch_rich_text_property(property_name, text)

notionary/page/service.py

@@ -14,59 +14,31 @@ from notionary.page.properties.factory import PagePropertyHandlerFactory
 from notionary.page.properties.models import PageTitleProperty
 from notionary.page.properties.service import PagePropertyHandler
 from notionary.page.schemas import NotionPageDto
-from notionary.shared.entity.dto_parsers import (
-    extract_cover_image_url_from_dto,
-    extract_emoji_icon_from_dto,
-    extract_external_icon_url_from_dto,
-)
 from notionary.shared.entity.service import Entity
-from notionary.user.schemas import PartialUserDto
 from notionary.workspace.query.service import WorkspaceQueryService
 
 
 class NotionPage(Entity):
     def __init__(
         self,
-        id: str,
+        dto: NotionPageDto,
         title: str,
-        created_time: str,
-        created_by: PartialUserDto,
-        last_edited_time: str,
-        last_edited_by: PartialUserDto,
-        url: str,
-        archived: bool,
-        in_trash: bool,
         page_property_handler: PagePropertyHandler,
         block_client: NotionBlockHttpClient,
         comment_service: CommentService,
         page_content_service: PageContentService,
         metadata_update_client: PageMetadataUpdateClient,
-        public_url: str | None = None,
-        emoji_icon: str | None = None,
-        external_icon_url: str | None = None,
-        cover_image_url: str | 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,
-        )
+        super().__init__(dto=dto)
+
         self._title = title
-        self._archived = archived
-        self._url = url
-        self._public_url = public_url
+        self._archived = dto.archived
 
         self._block_client = block_client
         self._comment_service = comment_service
         self._page_content_service = page_content_service
-        self.properties = page_property_handler
         self._metadata_update_client = metadata_update_client
+        self.properties = page_property_handler
 
     @classmethod
     async def from_id(
@@ -75,8 +47,8 @@ class NotionPage(Entity):
         page_property_handler_factory: PagePropertyHandlerFactory | None = None,
     ) -> Self:
         factory = page_property_handler_factory or PagePropertyHandlerFactory()
-        response = await cls._fetch_page_dto(page_id)
-        return await cls._create_from_dto(response, factory)
+        dto = await cls._fetch_page_dto(page_id)
+        return await cls._create_from_dto(dto, factory)
 
     @classmethod
     async def from_title(
@@ -95,76 +67,43 @@ class NotionPage(Entity):
     @classmethod
     async def _create_from_dto(
         cls,
-        response: NotionPageDto,
+        dto: NotionPageDto,
         page_property_handler_factory: PagePropertyHandlerFactory,
     ) -> Self:
-        title_task = cls._extract_title_from_dto(response)
-        page_property_handler = page_property_handler_factory.create_from_page_response(response)
+        title_task = cls._extract_title_from_dto(dto)
+        page_property_handler = page_property_handler_factory.create_from_page_response(dto)
 
         title = await title_task
 
         return cls._create_with_dependencies(
-            id=response.id,
+            dto=dto,
             title=title,
-            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,
             page_property_handler=page_property_handler,
-            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),
         )
 
     @classmethod
     def _create_with_dependencies(
         cls,
-        id: str,
+        dto: NotionPageDto,
         title: str,
-        created_time: str,
-        created_by: PartialUserDto,
-        last_edited_time: str,
-        last_edited_by: PartialUserDto,
-        url: str,
-        archived: bool,
-        in_trash: bool,
         page_property_handler: PagePropertyHandler,
-        public_url: str | None = None,
-        emoji_icon: str | None = None,
-        external_icon_url: str | None = None,
-        cover_image_url: str | None = None,
     ) -> Self:
         block_client = NotionBlockHttpClient()
         comment_service = CommentService()
 
         page_content_service_factory = PageContentServiceFactory()
-        page_content_service = page_content_service_factory.create(page_id=id, block_client=block_client)
+        page_content_service = page_content_service_factory.create(page_id=dto.id, block_client=block_client)
 
-        metadata_update_client = PageMetadataUpdateClient(page_id=id)
+        metadata_update_client = PageMetadataUpdateClient(page_id=dto.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,
-            url=url,
-            archived=archived,
-            in_trash=in_trash,
             page_property_handler=page_property_handler,
             block_client=block_client,
             comment_service=comment_service,
             page_content_service=page_content_service,
             metadata_update_client=metadata_update_client,
-            public_url=public_url,
-            emoji_icon=emoji_icon,
-            external_icon_url=external_icon_url,
-            cover_image_url=cover_image_url,
         )
 
     @staticmethod
@@ -185,8 +124,8 @@ class NotionPage(Entity):
         return self._title
 
     @property
-    def url(self) -> str:
-        return self._url
+    def archived(self) -> bool:
+        return self._archived
 
     @property
     def markdown_builder() -> MarkdownBuilder:

notionary/shared/entity/service.py

@@ -1,45 +1,68 @@
-from __future__ import annotations
-
 import random
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from typing import TYPE_CHECKING, Self
+from typing import Self
 
 from notionary.shared.entity.entity_metadata_update_client import EntityMetadataUpdateClient
-from notionary.user.schemas import PartialUserDto
+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.parent import ParentType
+from notionary.user.base import BaseUser
 from notionary.user.service import UserService
 from notionary.utils.mixins.logging import LoggingMixin
 from notionary.utils.uuid_utils import extract_uuid
 
-if TYPE_CHECKING:
-    from notionary.user.base import BaseUser
-
 
 class Entity(LoggingMixin, ABC):
     def __init__(
         self,
-        id: str,
-        created_time: str,
-        created_by: PartialUserDto,
-        last_edited_time: str,
-        last_edited_by: PartialUserDto,
-        in_trash: bool,
-        emoji_icon: str | None = None,
-        external_icon_url: str | None = None,
-        cover_image_url: str | None = None,
+        dto: EntityResponseDto,
         user_service: UserService | None = None,
     ) -> None:
-        self._id = id
-        self._created_time = created_time
-        self._created_by = created_by
-        self._last_edited_time = last_edited_time
-        self._last_edited_by = last_edited_by
-        self._emoji_icon = emoji_icon
-        self._external_icon_url = external_icon_url
-        self._cover_image_url = cover_image_url
-        self._in_trash = in_trash
+        self._id = dto.id
+        self._created_time = dto.created_time
+        self._created_by = dto.created_by
+        self._last_edited_time = dto.last_edited_time
+        self._last_edited_by = dto.last_edited_by
+        self._in_trash = dto.in_trash
+        self._parent = dto.parent
+        self._url = dto.url
+        self._public_url = dto.public_url
+
+        self._emoji_icon = self._extract_emoji_icon(dto)
+        self._external_icon_url = self._extract_external_icon_url(dto)
+        self._cover_image_url = self._extract_cover_image_url(dto)
+
         self._user_service = user_service or UserService()
 
+    @staticmethod
+    def _extract_emoji_icon(dto: EntityResponseDto) -> str | None:
+        if dto.icon is None:
+            return None
+        if dto.icon.type is not IconType.EMOJI:
+            return None
+
+        return dto.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
+
+    @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
+
     @classmethod
     @abstractmethod
     async def from_id(cls, id: str) -> Self:
@@ -93,12 +116,43 @@ class Entity(LoggingMixin, ABC):
         return self._cover_image_url
 
     @property
-    def created_by(self) -> PartialUserDto:
-        return self._created_by
+    def url(self) -> str:
+        return self._url
 
     @property
-    def last_edited_by(self) -> PartialUserDto:
-        return self._last_edited_by
+    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
+        return None
+
+    def get_parent_data_source_id_if_present(self) -> str | None:
+        if self._parent.type == ParentType.DATA_SOURCE_ID:
+            return self._parent.data_source_id
+        return None
+
+    def get_parent_page_id_if_present(self) -> str | None:
+        if self._parent.type == ParentType.PAGE_ID:
+            return self._parent.page_id
+        return None
+
+    def get_parent_block_id_if_present(self) -> str | None:
+        if self._parent.type == ParentType.BLOCK_ID:
+            return self._parent.block_id
+        return None
+
+    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)
@@ -106,17 +160,19 @@ class Entity(LoggingMixin, ABC):
     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)
-        self._emoji_icon = entity_response.icon.emoji if entity_response.icon else None
+        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)
         self._emoji_icon = None
-        self._external_icon_url = (
-            entity_response.icon.external.url if entity_response.icon and entity_response.icon.external else None
-        )
+        self._external_icon_url = self._extract_external_icon_url(entity_response)
 
     async def remove_icon(self) -> None:
         await self._entity_metadata_update_client.remove_icon()
@@ -125,9 +181,7 @@ class Entity(LoggingMixin, ABC):
 
     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)
-        self._cover_image_url = (
-            entity_response.cover.external.url if entity_response.cover and entity_response.cover.external else None
-        )
+        self._cover_image_url = self._extract_cover_image_url(entity_response)
 
     async def set_random_gradient_cover(self) -> None:
         random_cover_url = self._get_random_gradient_cover()
@@ -137,6 +191,10 @@ 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.")

notionary/utils/pagination.py

@@ -12,89 +12,93 @@ class PaginatedResponse(BaseModel):
 
 async def _fetch_data(
     api_call: Callable[..., Coroutine[Any, Any, PaginatedResponse]],
-    page_size: int | None = None,
+    total_results_limit: int | None = None,
     **kwargs,
 ) -> AsyncGenerator[PaginatedResponse]:
-    next_cursor = None
-    has_more = True
-    total_fetched = 0
+    next_cursor: str | None = None
+    has_more: bool = True
+    total_fetched: int = 0
+    api_page_size: int = kwargs.get("page_size", 100)
 
-    while has_more and _should_continue_fetching(page_size, total_fetched):
-        request_params = _build_request_params(kwargs, next_cursor, page_size)
+    while has_more and _should_continue_fetching(total_results_limit, total_fetched):
+        request_params = _build_request_params(kwargs, next_cursor)
         response = await api_call(**request_params)
 
-        limited_results = _apply_result_limit(response.results, page_size, 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)
+        yield _create_limited_response(response, limited_results, api_page_size)
 
-        if _has_reached_limit(page_size, total_fetched):
+        if _has_reached_limit(total_results_limit, total_fetched):
             break
 
         has_more = response.has_more
         next_cursor = response.next_cursor
 
 
-def _should_continue_fetching(page_size: int | None, total_fetched: int) -> bool:
-    if page_size is None:
+def _should_continue_fetching(total_limit: int | None, total_fetched: int) -> bool:
+    if total_limit is None:
         return True
-    return total_fetched < page_size
+    return total_fetched < total_limit
 
 
 def _build_request_params(
     base_kwargs: dict[str, Any],
     cursor: str | None,
-    page_size: int | None,
 ) -> dict[str, Any]:
     params = base_kwargs.copy()
-
     if cursor:
         params["start_cursor"] = cursor
-
-    if page_size:
-        params["page_size"] = page_size
-
     return params
 
 
-def _apply_result_limit(results: list[Any], page_size: int | None, total_fetched: int) -> list[Any]:
-    if page_size is None:
+def _apply_result_limit(results: list[Any], total_limit: int | None, total_fetched: int) -> list[Any]:
+    if total_limit is None:
         return results
 
-    remaining = page_size - total_fetched
-    return results[:remaining]
+    remaining_space = total_limit - total_fetched
+    return results[:remaining_space]
 
 
-def _has_reached_limit(page_size: int | None, total_fetched: int) -> bool:
-    if page_size is None:
+def _has_reached_limit(total_limit: int | None, total_fetched: int) -> bool:
+    if total_limit is None:
         return False
-    return total_fetched >= page_size
+    return total_fetched >= total_limit
+
+
+def _create_limited_response(
+    original: PaginatedResponse,
+    limited_results: list[Any],
+    api_page_size: int,
+) -> PaginatedResponse:
+    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
 
-def _create_limited_response(original: PaginatedResponse, limited_results: list[Any]) -> PaginatedResponse:
     return PaginatedResponse(
         results=limited_results,
-        has_more=original.has_more and len(limited_results) == len(original.results),
-        next_cursor=original.next_cursor,
+        has_more=has_more_after_limit,
+        next_cursor=original.next_cursor if has_more_after_limit else None,
     )
 
 
 async def paginate_notion_api(
     api_call: Callable[..., Coroutine[Any, Any, PaginatedResponse]],
-    page_size: int | None = None,
+    total_results_limit: int | None = None,
     **kwargs,
 ) -> list[Any]:
     all_results = []
-    async for page in _fetch_data(api_call, page_size=page_size, **kwargs):
+    async for page in _fetch_data(api_call, total_results_limit=total_results_limit, **kwargs):
         all_results.extend(page.results)
     return all_results
 
 
 async def paginate_notion_api_generator(
     api_call: Callable[..., Coroutine[Any, Any, PaginatedResponse]],
-    page_size: int | None = None,
+    total_results_limit: int | None = None,
     **kwargs,
 ) -> AsyncGenerator[Any]:
-    async for page in _fetch_data(api_call, page_size=page_size, **kwargs):
+    async for page in _fetch_data(api_call, total_results_limit, **kwargs):
         for item in page.results:
             yield item

notionary/workspace/__init__.py

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

notionary/workspace/client.py

@@ -22,6 +22,7 @@ class WorkspaceClient:
         async for page in paginate_notion_api_generator(
             self._query_pages,
             search_config=search_config,
+            total_results_limit=search_config.total_results_limit,
         ):
             yield page
 
@@ -32,6 +33,7 @@ class WorkspaceClient:
         async for data_source in paginate_notion_api_generator(
             self._query_data_sources,
             search_config=search_config,
+            total_results_limit=search_config.total_results_limit,
         ):
             yield data_source
 

notionary/workspace/query/__init__.py

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