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

notionary/page/content/syntax/registry.py

@@ -0,0 +1,393 @@
+import re
+
+from notionary.page.content.syntax.grammar import MarkdownGrammar
+from notionary.page.content.syntax.models import SyntaxDefinition, SyntaxRegistryKey
+
+
+class SyntaxRegistry:
+    def __init__(self, markdown_markdown_grammar: MarkdownGrammar | None = None) -> None:
+        self._markdown_grammar = markdown_markdown_grammar or MarkdownGrammar()
+
+        self._definitions: dict[SyntaxRegistryKey, SyntaxDefinition] = {}
+        self._register_defaults()
+
+    def get_audio_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.AUDIO]
+
+    def get_bookmark_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.BOOKMARK]
+
+    def get_breadcrumb_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.BREADCRUMB]
+
+    def get_bulleted_list_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.BULLETED_LIST]
+
+    def get_callout_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.CALLOUT]
+
+    def get_code_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.CODE]
+
+    def get_column_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.COLUMN]
+
+    def get_column_list_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.COLUMN_LIST]
+
+    def get_divider_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.DIVIDER]
+
+    def get_embed_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.EMBED]
+
+    def get_equation_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.EQUATION]
+
+    def get_file_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.FILE]
+
+    def get_image_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.IMAGE]
+
+    def get_numbered_list_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.NUMBERED_LIST]
+
+    def get_pdf_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.PDF]
+
+    def get_quote_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.QUOTE]
+
+    def get_table_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.TABLE]
+
+    def get_table_row_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.TABLE_ROW]
+
+    def get_table_of_contents_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.TABLE_OF_CONTENTS]
+
+    def get_todo_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.TO_DO]
+
+    def get_todo_done_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.TO_DO_DONE]
+
+    def get_toggle_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.TOGGLE]
+
+    def get_toggleable_heading_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.TOGGLEABLE_HEADING]
+
+    def get_video_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.VIDEO]
+
+    def get_caption_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.CAPTION]
+
+    def get_space_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.SPACE]
+
+    def get_heading_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.HEADING]
+
+    def _register_defaults(self) -> None:
+        self._register_audio_syntax()
+        self._register_bookmark_syntax()
+        self._register_image_syntax()
+        self._register_video_syntax()
+        self._register_file_syntax()
+        self._register_pdf_syntax()
+
+        # List blocks
+        self._register_bulleted_list_syntax()
+        self._register_numbered_list_syntax()
+        self._register_todo_syntax()
+        self._register_todo_done_syntax()
+
+        # Container blocks
+        self._register_toggle_syntax()
+        self._register_toggleable_heading_syntax()
+        self._register_callout_syntax()
+        self._register_quote_syntax()
+        self._register_code_syntax()
+
+        # Column layout blocks
+        self._register_column_list_syntax()
+        self._register_column_syntax()
+
+        self._register_heading_1_syntax()
+        self._register_heading_2_syntax()
+        self._register_heading_3_syntax()
+        self._register_heading_syntax()  # Shared pattern for regular headings
+
+        self._register_divider_syntax()
+        self._register_breadcrumb_syntax()
+        self._register_table_of_contents_syntax()
+        self._register_equation_syntax()
+        self._register_embed_syntax()
+        self._register_table_syntax()
+        self._register_table_row_syntax()
+
+        # Post-processing and utility blocks
+        self._register_caption_syntax()
+        self._register_space_syntax()
+
+    def _register_audio_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[audio](",
+            end_delimiter=")",
+            regex_pattern=re.compile(r"\[audio\]\(([^)]+)\)"),
+        )
+        self._definitions[SyntaxRegistryKey.AUDIO] = definition
+
+    def _register_bookmark_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[bookmark](",
+            end_delimiter=")",
+            regex_pattern=re.compile(r"\[bookmark\]\((https?://[^\s\"]+)\)"),
+        )
+        self._definitions[SyntaxRegistryKey.BOOKMARK] = definition
+
+    def _register_breadcrumb_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[breadcrumb]",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^\[breadcrumb\]\s*$", re.IGNORECASE),
+        )
+        self._definitions[SyntaxRegistryKey.BREADCRUMB] = definition
+
+    def _register_bulleted_list_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="- ",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^(\s*)-\s+(?!\[[ xX]\])(.+)$"),
+        )
+        self._definitions[SyntaxRegistryKey.BULLETED_LIST] = definition
+
+    def _register_callout_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[callout]",
+            end_delimiter=")",
+            regex_pattern=re.compile(
+                r'\[callout\](?:\(([^")]+?)(?:\s+"([^"]+)")?\)|(?:\s+([^"\n]+?)(?:\s+"([^"]+)")?)(?:\n|$))'
+            ),
+        )
+        self._definitions[SyntaxRegistryKey.CALLOUT] = definition
+
+    def _register_code_syntax(self) -> None:
+        code_delimiter = "```"
+        definition = SyntaxDefinition(
+            start_delimiter=code_delimiter,
+            end_delimiter=code_delimiter,
+            regex_pattern=re.compile("^" + re.escape(code_delimiter) + r"(\w*)\s*$"),
+            end_regex_pattern=re.compile("^" + re.escape(code_delimiter) + r"\s*$"),
+        )
+        self._definitions[SyntaxRegistryKey.CODE] = definition
+
+    def _register_column_syntax(self) -> None:
+        delimiter = self._markdown_grammar.column_delimiter
+        definition = SyntaxDefinition(
+            start_delimiter=f"{delimiter} column",
+            end_delimiter=delimiter,
+            regex_pattern=re.compile(
+                rf"^{re.escape(delimiter)}\s*column(?:\s+(0?\.\d+|1(?:\.0?)?))??\s*$",
+                re.IGNORECASE | re.MULTILINE,
+            ),
+            end_regex_pattern=re.compile(rf"^{re.escape(delimiter)}\s*$", re.MULTILINE),
+        )
+        self._definitions[SyntaxRegistryKey.COLUMN] = definition
+
+    def _register_column_list_syntax(self) -> None:
+        delimiter = self._markdown_grammar.column_delimiter
+        definition = SyntaxDefinition(
+            start_delimiter=f"{delimiter} columns",
+            end_delimiter=delimiter,
+            regex_pattern=re.compile(rf"^{re.escape(delimiter)}\s*columns?\s*$", re.IGNORECASE),
+            end_regex_pattern=re.compile(rf"^{re.escape(delimiter)}\s*$"),
+        )
+        self._definitions[SyntaxRegistryKey.COLUMN_LIST] = definition
+
+    def _register_divider_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="---",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^\s*-{3,}\s*$"),
+        )
+        self._definitions[SyntaxRegistryKey.DIVIDER] = definition
+
+    def _register_embed_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[embed](",
+            end_delimiter=")",
+            regex_pattern=re.compile(r"\[embed\]\((https?://[^\s)]+)\)"),
+        )
+        self._definitions[SyntaxRegistryKey.EMBED] = definition
+
+    def _register_equation_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="$$",
+            end_delimiter="$$",
+            regex_pattern=re.compile(r"^\$\$\s*$"),
+        )
+        self._definitions[SyntaxRegistryKey.EQUATION] = definition
+
+    def _register_file_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[file](",
+            end_delimiter=")",
+            regex_pattern=re.compile(r"\[file\]\(([^)]+)\)"),
+        )
+        self._definitions[SyntaxRegistryKey.FILE] = definition
+
+    def _register_heading_1_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="# ",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^#\s+(.+)$"),
+        )
+        self._definitions[SyntaxRegistryKey.HEADING_1] = definition
+
+    def _register_heading_2_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="## ",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^#{2}\s+(.+)$"),
+        )
+        self._definitions[SyntaxRegistryKey.HEADING_2] = definition
+
+    def _register_heading_3_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="### ",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^#{3}\s+(.+)$"),
+        )
+        self._definitions[SyntaxRegistryKey.HEADING_3] = definition
+
+    def _register_image_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[image](",
+            end_delimiter=")",
+            regex_pattern=re.compile(r"(?<!!)\[image\]\(([^)]+)\)"),
+        )
+        self._definitions[SyntaxRegistryKey.IMAGE] = definition
+
+    def _register_numbered_list_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="1. ",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^(\s*)(\d+)\.\s+(.+)$"),
+        )
+        self._definitions[SyntaxRegistryKey.NUMBERED_LIST] = definition
+
+    def _register_pdf_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[pdf](",
+            end_delimiter=")",
+            regex_pattern=re.compile(r"\[pdf\]\(([^)]+)\)"),
+        )
+        self._definitions[SyntaxRegistryKey.PDF] = definition
+
+    def _register_quote_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="> ",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^>(?!>)\s*(.+)$"),
+        )
+        self._definitions[SyntaxRegistryKey.QUOTE] = definition
+
+    def _register_table_syntax(self) -> None:
+        delimiter = self._markdown_grammar.table_delimiter
+        definition = SyntaxDefinition(
+            start_delimiter=delimiter,
+            end_delimiter="",
+            regex_pattern=re.compile(rf"^\s*{re.escape(delimiter)}(.+){re.escape(delimiter)}\s*$"),
+        )
+        self._definitions[SyntaxRegistryKey.TABLE] = definition
+
+    def _register_table_row_syntax(self) -> None:
+        delimiter = self._markdown_grammar.table_delimiter
+        definition = SyntaxDefinition(
+            start_delimiter=delimiter,
+            end_delimiter="",
+            regex_pattern=re.compile(rf"^\s*{re.escape(delimiter)}([\s\-:|]+){re.escape(delimiter)}\s*$"),
+        )
+        self._definitions[SyntaxRegistryKey.TABLE_ROW] = definition
+
+    def _register_table_of_contents_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[toc]",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^\[toc\]$", re.IGNORECASE),
+        )
+        self._definitions[SyntaxRegistryKey.TABLE_OF_CONTENTS] = definition
+
+    def _register_todo_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="- [ ]",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^\s*-\s+\[ \]\s+(.+)$"),
+        )
+        self._definitions[SyntaxRegistryKey.TO_DO] = definition
+
+    def _register_todo_done_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="- [x]",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^\s*-\s+\[x\]\s+(.+)$", re.IGNORECASE),
+        )
+        self._definitions[SyntaxRegistryKey.TO_DO_DONE] = definition
+
+    def _register_toggle_syntax(self) -> None:
+        delimiter = self._markdown_grammar.toggle_delimiter
+        definition = SyntaxDefinition(
+            start_delimiter=delimiter,
+            end_delimiter=delimiter,
+            regex_pattern=re.compile(rf"^{re.escape(delimiter)}\s+(.+)$"),
+            end_regex_pattern=re.compile(rf"^{re.escape(delimiter)}\s*$"),
+        )
+        self._definitions[SyntaxRegistryKey.TOGGLE] = definition
+
+    def _register_toggleable_heading_syntax(self) -> None:
+        delimiter = self._markdown_grammar.toggle_delimiter
+        escaped_delimiter = re.escape(delimiter)
+        definition = SyntaxDefinition(
+            start_delimiter=f"{delimiter} #",
+            end_delimiter=delimiter,
+            regex_pattern=re.compile(rf"^{escaped_delimiter}\s*(?P<level>#{{1,3}})(?!#)\s*(.+)$", re.IGNORECASE),
+            end_regex_pattern=re.compile(rf"^{escaped_delimiter}\s*$"),
+        )
+        self._definitions[SyntaxRegistryKey.TOGGLEABLE_HEADING] = definition
+
+    def _register_video_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[video](",
+            end_delimiter=")",
+            regex_pattern=re.compile(r"\[video\]\(([^)]+)\)"),
+        )
+        self._definitions[SyntaxRegistryKey.VIDEO] = definition
+
+    def _register_caption_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[caption]",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^\[caption\]\s+(\S.*)$"),
+        )
+        self._definitions[SyntaxRegistryKey.CAPTION] = definition
+
+    def _register_space_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[space]",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^\[space\]\s*$"),
+        )
+        self._definitions[SyntaxRegistryKey.SPACE] = definition
+
+    def _register_heading_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="#",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^(#{1,3})[ \t]+(.+)$"),
+        )
+        self._definitions[SyntaxRegistryKey.HEADING] = definition

notionary/page/page_context.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
-from dataclasses import dataclass
 from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from notionary.database.client import NotionDatabaseClient
-    from notionary.file_upload import NotionFileUploadClient
+    from notionary.file_upload import FileUploadHttpClient
 
 
 @dataclass(frozen=True)
@@ -14,35 +13,27 @@ class PageContextProvider:
     """Context object that provides dependencies for block conversion operations."""
 
     page_id: str
-    database_client: NotionDatabaseClient
-    file_upload_client: NotionFileUploadClient
+    file_upload_client: FileUploadHttpClient
 
 
 # Context variable
-_page_context: ContextVar[Optional[PageContextProvider]] = ContextVar(
-    "page_context", default=None
-)
+_page_context: ContextVar[PageContextProvider | None] = ContextVar("page_context", default=None)
 
 
 def get_page_context() -> PageContextProvider:
     """Get current page context or raise if not available."""
     context = _page_context.get()
     if context is None:
-        raise RuntimeError(
-            "No page context available. Use 'async with page_context(...)'"
-        )
+        raise RuntimeError("No page context available. Use 'async with page_context(...)'")
     return context
 
 
 class page_context:
-    """Async-only context manager for page operations."""
-
-    def __init__(self, provider: PageContextProvider):
+    def __init__(self, provider: PageContextProvider) -> None:
         self.provider = provider
         self._token = None
 
     def _set_context(self) -> PageContextProvider:
-        """Helper to set context and return provider."""
         self._token = _page_context.set(self.provider)
         return self.provider
 

notionary/page/page_http_client.py

@@ -0,0 +1,15 @@
+from notionary.http.client import NotionHttpClient
+from notionary.page.schemas import NotionPageDto
+
+
+class NotionPageHttpClient(NotionHttpClient):
+    def __init__(
+        self,
+        page_id: str,
+    ):
+        super().__init__()
+        self._page_id = page_id
+
+    async def get_page(self) -> NotionPageDto:
+        response = await self.get(f"pages/{self._page_id}")
+        return NotionPageDto.model_validate(response)

notionary/page/page_metadata_update_client.py

@@ -0,0 +1,19 @@
+from typing import override
+
+from notionary.http.client import NotionHttpClient
+from notionary.page.schemas import NotionPageDto
+from notionary.shared.entity.entity_metadata_update_client import EntityMetadataUpdateClient
+from notionary.shared.entity.schemas import NotionEntityUpdateDto
+
+
+class PageMetadataUpdateClient(NotionHttpClient, EntityMetadataUpdateClient):
+    def __init__(self, page_id: str, timeout: int = 30) -> None:
+        super().__init__(timeout)
+        self._page_id = page_id
+
+    @override
+    async def patch_metadata(self, updated_data: NotionEntityUpdateDto) -> NotionPageDto:
+        updated_data_dict = updated_data.model_dump(exclude_unset=True, exclude_none=True)
+
+        response_dict = await self.patch(f"pages/{self._page_id}", data=updated_data_dict)
+        return NotionPageDto.model_validate(response_dict)

notionary/page/properties/client.py

@@ -0,0 +1,144 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+from notionary.blocks.rich_text.models import RichText
+from notionary.http.client import NotionHttpClient
+from notionary.page.properties.models import (
+    DateValue,
+    PageCheckboxProperty,
+    PageDateProperty,
+    PageEmailProperty,
+    PageMultiSelectProperty,
+    PageNumberProperty,
+    PagePhoneNumberProperty,
+    PagePropertyT,
+    PageRelationProperty,
+    PageRichTextProperty,
+    PageSelectProperty,
+    PageStatusProperty,
+    PageTitleProperty,
+    PageURLProperty,
+    RelationItem,
+    SelectOption,
+    StatusOption,
+)
+from notionary.page.schemas import NotionPageDto, PgePropertiesUpdateDto
+
+
+class PagePropertyHttpClient(NotionHttpClient):
+    def __init__(self, page_id: str) -> None:
+        super().__init__()
+        self._page_id = page_id
+
+    async def patch_page(self, data: BaseModel) -> NotionPageDto:
+        data_dict = data.model_dump(exclude_unset=True, exclude_none=True)
+
+        result_dict = await self.patch(f"pages/{self._page_id}", data=data_dict)
+        return NotionPageDto.model_validate(result_dict)
+
+    async def _patch_property(
+        self,
+        property_name: str,
+        value: Any,
+        property_type: type[PagePropertyT],
+        current_property: PagePropertyT | None = None,
+    ) -> NotionPageDto:
+        updated_property = self._create_updated_property(property_type, current_property, value)
+
+        properties = {property_name: updated_property}
+        update_dto = PgePropertiesUpdateDto(properties=properties)
+
+        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_rich_text_property(self, property_name: str, text: str) -> NotionPageDto:
+        return await self._patch_property(property_name, text, PageRichTextProperty)
+
+    async def patch_url_property(self, property_name: str, url: str) -> NotionPageDto:
+        return await self._patch_property(property_name, url, PageURLProperty)
+
+    async def patch_email_property(self, property_name: str, email: str) -> NotionPageDto:
+        return await self._patch_property(property_name, email, PageEmailProperty)
+
+    async def patch_phone_property(self, property_name: str, phone: str) -> NotionPageDto:
+        return await self._patch_property(property_name, phone, PagePhoneNumberProperty)
+
+    async def patch_number_property(self, property_name: str, number: int | float) -> NotionPageDto:
+        return await self._patch_property(property_name, number, PageNumberProperty)
+
+    async def patch_checkbox_property(self, property_name: str, checked: bool) -> NotionPageDto:
+        return await self._patch_property(property_name, checked, PageCheckboxProperty)
+
+    async def patch_select_property(self, property_name: str, value: str) -> NotionPageDto:
+        return await self._patch_property(property_name, value, PageSelectProperty)
+
+    async def patch_multi_select_property(self, property_name: str, values: list[str]) -> NotionPageDto:
+        return await self._patch_property(property_name, values, PageMultiSelectProperty)
+
+    async def patch_date_property(self, property_name: str, date_value: str | dict) -> NotionPageDto:
+        return await self._patch_property(property_name, date_value, PageDateProperty)
+
+    async def patch_status_property(self, property_name: str, status: str) -> NotionPageDto:
+        return await self._patch_property(property_name, status, PageStatusProperty)
+
+    async def patch_relation_property(self, property_name: str, relation_ids: str | list[str]) -> NotionPageDto:
+        if isinstance(relation_ids, str):
+            relation_ids = [relation_ids]
+        return await self._patch_property(property_name, relation_ids, PageRelationProperty)
+
+    # TODO: Fix this shit here
+    def _create_updated_property(
+        self,
+        property_type: type[PagePropertyT],
+        current_property: PagePropertyT | None,
+        value: Any,
+    ) -> PagePropertyT:
+        """
+        Creates an updated property instance based on the property type and new value.
+        """
+        # Get the property ID from the current property if it exists
+        property_id = current_property.id if current_property else ""
+
+        if property_type == PageTitleProperty:
+            return PageTitleProperty(
+                id=property_id,
+                title=[RichText(type="text", text={"content": str(value)})],
+            )
+        elif property_type == PageRichTextProperty:
+            return PageRichTextProperty(
+                id=property_id,
+                rich_text=[RichText(type="text", text={"content": str(value)})],
+            )
+        elif property_type == PageURLProperty:
+            return PageURLProperty(id=property_id, url=str(value))
+        elif property_type == PageEmailProperty:
+            return PageEmailProperty(id=property_id, email=str(value))
+        elif property_type == PagePhoneNumberProperty:
+            return PagePhoneNumberProperty(id=property_id, phone_number=str(value))
+        elif property_type == PageNumberProperty:
+            return PageNumberProperty(id=property_id, number=float(value))
+        elif property_type == PageCheckboxProperty:
+            return PageCheckboxProperty(id=property_id, checkbox=bool(value))
+        elif property_type == PageSelectProperty:
+            select_option = SelectOption(name=str(value))
+            return PageSelectProperty(id=property_id, select=select_option)
+        elif property_type == PageMultiSelectProperty:
+            multi_select_options = [SelectOption(id="", name=str(item)) for item in value]
+            return PageMultiSelectProperty(id=property_id, multi_select=multi_select_options)
+        elif property_type == PageDateProperty:
+            if isinstance(value, dict) and "start" in value:
+                date_value = DateValue(**value)
+            else:
+                date_value = DateValue(start=str(value))
+            return PageDateProperty(id=property_id, date=date_value)
+        elif property_type == PageStatusProperty:
+            status_option = StatusOption(id="", name=str(value))
+            return PageStatusProperty(id=property_id, status=status_option)
+        elif property_type == PageRelationProperty:
+            relation_items = [RelationItem(id=str(item)) for item in value]
+            return PageRelationProperty(id=property_id, relation=relation_items)
+        else:
+            raise ValueError(f"Unsupported property type: {property_type}")

notionary/page/properties/factory.py

@@ -0,0 +1,26 @@
+from typing import cast
+
+from notionary.page.properties.client import PagePropertyHttpClient
+from notionary.page.properties.service import PagePropertyHandler
+from notionary.page.schemas import NotionPageDto
+from notionary.shared.models.parent import DataSourceParent, ParentType
+
+
+class PagePropertyHandlerFactory:
+    def create_from_page_response(self, page_response: NotionPageDto) -> PagePropertyHandler:
+        return PagePropertyHandler(
+            properties=page_response.properties,
+            parent_type=page_response.parent.type,
+            page_url=page_response.url,
+            page_property_http_client=self._create_http_client(page_id=page_response.id),
+            parent_data_source=self._extract_parent_data_source_id(page_response),
+        )
+
+    def _create_http_client(self, page_id: str) -> PagePropertyHttpClient:
+        return PagePropertyHttpClient(page_id=page_id)
+
+    def _extract_parent_data_source_id(self, response: NotionPageDto) -> str | None:
+        if response.parent.type != ParentType.DATA_SOURCE_ID:
+            return None
+        data_source_parent = cast(DataSourceParent, response.parent)
+        return data_source_parent.data_source_id if data_source_parent else None