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

notionary/page/content/syntax/{service.py → registry.py}

@@ -1,14 +1,13 @@
 import re
 
+from notionary.page.content.syntax.grammar import MarkdownGrammar
 from notionary.page.content.syntax.models import SyntaxDefinition, SyntaxRegistryKey
 
 
 class SyntaxRegistry:
-    MULTI_LINE_BLOCK_DELIMITER = ":::"
-    TOGGLE_DELIMITER = "+++"
-    TABLE_DELIMITER = "|"
+    def __init__(self, markdown_markdown_grammar: MarkdownGrammar | None = None) -> None:
+        self._markdown_grammar = markdown_markdown_grammar or MarkdownGrammar()
 
-    def __init__(self) -> None:
         self._definitions: dict[SyntaxRegistryKey, SyntaxDefinition] = {}
         self._register_defaults()
 
@@ -140,8 +139,6 @@ class SyntaxRegistry:
             start_delimiter="[audio](",
             end_delimiter=")",
             regex_pattern=re.compile(r"\[audio\]\(([^)]+)\)"),
-            is_multiline_block=False,
-            is_inline=True,
         )
         self._definitions[SyntaxRegistryKey.AUDIO] = definition
 
@@ -150,8 +147,6 @@ class SyntaxRegistry:
             start_delimiter="[bookmark](",
             end_delimiter=")",
             regex_pattern=re.compile(r"\[bookmark\]\((https?://[^\s\"]+)\)"),
-            is_multiline_block=False,
-            is_inline=True,
         )
         self._definitions[SyntaxRegistryKey.BOOKMARK] = definition
 
@@ -160,8 +155,6 @@ class SyntaxRegistry:
             start_delimiter="[breadcrumb]",
             end_delimiter="",
             regex_pattern=re.compile(r"^\[breadcrumb\]\s*$", re.IGNORECASE),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.BREADCRUMB] = definition
 
@@ -170,21 +163,16 @@ class SyntaxRegistry:
             start_delimiter="- ",
             end_delimiter="",
             regex_pattern=re.compile(r"^(\s*)-\s+(?!\[[ xX]\])(.+)$"),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.BULLETED_LIST] = definition
 
     def _register_callout_syntax(self) -> None:
         definition = SyntaxDefinition(
-            start_delimiter=f"{self.MULTI_LINE_BLOCK_DELIMITER} callout",
-            end_delimiter=self.MULTI_LINE_BLOCK_DELIMITER,
+            start_delimiter="[callout]",
+            end_delimiter=")",
             regex_pattern=re.compile(
-                rf"^{re.escape(self.MULTI_LINE_BLOCK_DELIMITER)}\s*callout(?:\s+(\S+))?\s*$", re.IGNORECASE
+                r'\[callout\](?:\(([^")]+?)(?:\s+"([^"]+)")?\)|(?:\s+([^"\n]+?)(?:\s+"([^"]+)")?)(?:\n|$))'
             ),
-            end_regex_pattern=re.compile(rf"^{re.escape(self.MULTI_LINE_BLOCK_DELIMITER)}\s*$"),
-            is_multiline_block=True,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.CALLOUT] = definition
 
@@ -195,33 +183,29 @@ class SyntaxRegistry:
             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*$"),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.CODE] = definition
 
     def _register_column_syntax(self) -> None:
+        delimiter = self._markdown_grammar.column_delimiter
         definition = SyntaxDefinition(
-            start_delimiter=f"{self.MULTI_LINE_BLOCK_DELIMITER} column",
-            end_delimiter=self.MULTI_LINE_BLOCK_DELIMITER,
+            start_delimiter=f"{delimiter} column",
+            end_delimiter=delimiter,
             regex_pattern=re.compile(
-                rf"^{re.escape(self.MULTI_LINE_BLOCK_DELIMITER)}\s*column(?:\s+(0?\.\d+|1(?:\.0?)?))??\s*$",
+                rf"^{re.escape(delimiter)}\s*column(?:\s+(0?\.\d+|1(?:\.0?)?))??\s*$",
                 re.IGNORECASE | re.MULTILINE,
             ),
-            end_regex_pattern=re.compile(rf"^{re.escape(self.MULTI_LINE_BLOCK_DELIMITER)}\s*$", re.MULTILINE),
-            is_multiline_block=True,
-            is_inline=False,
+            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"{self.MULTI_LINE_BLOCK_DELIMITER} columns",
-            end_delimiter=self.MULTI_LINE_BLOCK_DELIMITER,
-            regex_pattern=re.compile(rf"^{re.escape(self.MULTI_LINE_BLOCK_DELIMITER)}\s*columns?\s*$", re.IGNORECASE),
-            end_regex_pattern=re.compile(rf"^{re.escape(self.MULTI_LINE_BLOCK_DELIMITER)}\s*$"),
-            is_multiline_block=True,
-            is_inline=False,
+            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
 
@@ -230,8 +214,6 @@ class SyntaxRegistry:
             start_delimiter="---",
             end_delimiter="",
             regex_pattern=re.compile(r"^\s*-{3,}\s*$"),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.DIVIDER] = definition
 
@@ -240,8 +222,6 @@ class SyntaxRegistry:
             start_delimiter="[embed](",
             end_delimiter=")",
             regex_pattern=re.compile(r"\[embed\]\((https?://[^\s)]+)\)"),
-            is_multiline_block=False,
-            is_inline=True,
         )
         self._definitions[SyntaxRegistryKey.EMBED] = definition
 
@@ -250,8 +230,6 @@ class SyntaxRegistry:
             start_delimiter="$$",
             end_delimiter="$$",
             regex_pattern=re.compile(r"^\$\$\s*$"),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.EQUATION] = definition
 
@@ -260,8 +238,6 @@ class SyntaxRegistry:
             start_delimiter="[file](",
             end_delimiter=")",
             regex_pattern=re.compile(r"\[file\]\(([^)]+)\)"),
-            is_multiline_block=False,
-            is_inline=True,
         )
         self._definitions[SyntaxRegistryKey.FILE] = definition
 
@@ -270,8 +246,6 @@ class SyntaxRegistry:
             start_delimiter="# ",
             end_delimiter="",
             regex_pattern=re.compile(r"^#\s+(.+)$"),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.HEADING_1] = definition
 
@@ -280,8 +254,6 @@ class SyntaxRegistry:
             start_delimiter="## ",
             end_delimiter="",
             regex_pattern=re.compile(r"^#{2}\s+(.+)$"),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.HEADING_2] = definition
 
@@ -290,8 +262,6 @@ class SyntaxRegistry:
             start_delimiter="### ",
             end_delimiter="",
             regex_pattern=re.compile(r"^#{3}\s+(.+)$"),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.HEADING_3] = definition
 
@@ -300,8 +270,6 @@ class SyntaxRegistry:
             start_delimiter="[image](",
             end_delimiter=")",
             regex_pattern=re.compile(r"(?<!!)\[image\]\(([^)]+)\)"),
-            is_multiline_block=False,
-            is_inline=True,
         )
         self._definitions[SyntaxRegistryKey.IMAGE] = definition
 
@@ -310,8 +278,6 @@ class SyntaxRegistry:
             start_delimiter="1. ",
             end_delimiter="",
             regex_pattern=re.compile(r"^(\s*)(\d+)\.\s+(.+)$"),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.NUMBERED_LIST] = definition
 
@@ -320,8 +286,6 @@ class SyntaxRegistry:
             start_delimiter="[pdf](",
             end_delimiter=")",
             regex_pattern=re.compile(r"\[pdf\]\(([^)]+)\)"),
-            is_multiline_block=False,
-            is_inline=True,
         )
         self._definitions[SyntaxRegistryKey.PDF] = definition
 
@@ -330,32 +294,24 @@ class SyntaxRegistry:
             start_delimiter="> ",
             end_delimiter="",
             regex_pattern=re.compile(r"^>(?!>)\s*(.+)$"),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.QUOTE] = definition
 
     def _register_table_syntax(self) -> None:
+        delimiter = self._markdown_grammar.table_delimiter
         definition = SyntaxDefinition(
-            start_delimiter=self.TABLE_DELIMITER,
+            start_delimiter=delimiter,
             end_delimiter="",
-            regex_pattern=re.compile(
-                rf"^\s*{re.escape(self.TABLE_DELIMITER)}(.+){re.escape(self.TABLE_DELIMITER)}\s*$"
-            ),
-            is_multiline_block=False,
-            is_inline=False,
+            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=self.TABLE_DELIMITER,
+            start_delimiter=delimiter,
             end_delimiter="",
-            regex_pattern=re.compile(
-                rf"^\s*{re.escape(self.TABLE_DELIMITER)}([\s\-:|]+){re.escape(self.TABLE_DELIMITER)}\s*$"
-            ),
-            is_multiline_block=False,
-            is_inline=False,
+            regex_pattern=re.compile(rf"^\s*{re.escape(delimiter)}([\s\-:|]+){re.escape(delimiter)}\s*$"),
         )
         self._definitions[SyntaxRegistryKey.TABLE_ROW] = definition
 
@@ -364,8 +320,6 @@ class SyntaxRegistry:
             start_delimiter="[toc]",
             end_delimiter="",
             regex_pattern=re.compile(r"^\[toc\]$", re.IGNORECASE),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.TABLE_OF_CONTENTS] = definition
 
@@ -374,8 +328,6 @@ class SyntaxRegistry:
             start_delimiter="- [ ]",
             end_delimiter="",
             regex_pattern=re.compile(r"^\s*-\s+\[ \]\s+(.+)$"),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.TO_DO] = definition
 
@@ -384,31 +336,27 @@ class SyntaxRegistry:
             start_delimiter="- [x]",
             end_delimiter="",
             regex_pattern=re.compile(r"^\s*-\s+\[x\]\s+(.+)$", re.IGNORECASE),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.TO_DO_DONE] = definition
 
     def _register_toggle_syntax(self) -> None:
+        delimiter = self._markdown_grammar.toggle_delimiter
         definition = SyntaxDefinition(
-            start_delimiter=self.TOGGLE_DELIMITER,
-            end_delimiter=self.TOGGLE_DELIMITER,
-            regex_pattern=re.compile(rf"^{re.escape(self.TOGGLE_DELIMITER)}\s+(.+)$"),
-            end_regex_pattern=re.compile(rf"^{re.escape(self.TOGGLE_DELIMITER)}\s*$"),
-            is_multiline_block=True,
-            is_inline=False,
+            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:
-        escaped_delimiter = re.escape(self.TOGGLE_DELIMITER)
+        delimiter = self._markdown_grammar.toggle_delimiter
+        escaped_delimiter = re.escape(delimiter)
         definition = SyntaxDefinition(
-            start_delimiter=f"{self.TOGGLE_DELIMITER} #",
-            end_delimiter=self.TOGGLE_DELIMITER,
+            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*$"),
-            is_multiline_block=True,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.TOGGLEABLE_HEADING] = definition
 
@@ -417,8 +365,6 @@ class SyntaxRegistry:
             start_delimiter="[video](",
             end_delimiter=")",
             regex_pattern=re.compile(r"\[video\]\(([^)]+)\)"),
-            is_multiline_block=False,
-            is_inline=True,
         )
         self._definitions[SyntaxRegistryKey.VIDEO] = definition
 
@@ -427,8 +373,6 @@ class SyntaxRegistry:
             start_delimiter="[caption]",
             end_delimiter="",
             regex_pattern=re.compile(r"^\[caption\]\s+(\S.*)$"),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.CAPTION] = definition
 
@@ -437,8 +381,6 @@ class SyntaxRegistry:
             start_delimiter="[space]",
             end_delimiter="",
             regex_pattern=re.compile(r"^\[space\]\s*$"),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.SPACE] = definition
 
@@ -447,7 +389,5 @@ class SyntaxRegistry:
             start_delimiter="#",
             end_delimiter="",
             regex_pattern=re.compile(r"^(#{1,3})[ \t]+(.+)$"),
-            is_multiline_block=False,
-            is_inline=False,
         )
         self._definitions[SyntaxRegistryKey.HEADING] = definition

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)
@@ -123,7 +123,7 @@ class PagePropertyHttpClient(NotionHttpClient):
         elif property_type == PageCheckboxProperty:
             return PageCheckboxProperty(id=property_id, checkbox=bool(value))
         elif property_type == PageSelectProperty:
-            select_option = SelectOption(id="", name=str(value))
+            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]

notionary/page/properties/models.py

@@ -5,6 +5,7 @@ from pydantic import BaseModel, Field
 
 from notionary.blocks.rich_text.models import RichText
 from notionary.shared.properties.type import PropertyType
+from notionary.shared.typings import JsonDict
 from notionary.user.schemas import PersonUserResponseDto, UserResponseDto
 
 # ============================================================================
@@ -23,7 +24,7 @@ class StatusOption(BaseModel):
 
 
 class SelectOption(BaseModel):
-    id: str
+    id: str | None = None
     name: str
 
 
@@ -269,7 +270,7 @@ class PageVerificationProperty(PageProperty):
 
 class PageButtonProperty(PageProperty):
     type: Literal[PropertyType.BUTTON] = PropertyType.BUTTON
-    button: dict[str, Any] = Field(default_factory=dict)
+    button: JsonDict = Field(default_factory=dict)
 
 
 # ============================================================================

notionary/page/properties/service.py

@@ -139,15 +139,30 @@ class PagePropertyHandler:
         data_source = await self._get_parent_data_source_or_raise()
         return await data_source.get_options_for_property_by_name(property_name)
 
+    async def get_schema_description(self, property_name: str) -> str:
+        data_source = await self._get_parent_data_source_or_raise()
+        return await data_source.get_schema_description(property_name)
+
     # =========================================================================
     # 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,18 +47,17 @@ 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(
         cls,
         page_title: str,
-        min_similarity: float = 0.6,
         search_service: WorkspaceQueryService | None = None,
     ) -> Self:
         service = search_service or WorkspaceQueryService()
-        return await service.find_page(page_title, min_similarity=min_similarity)
+        return await service.find_page(page_title)
 
     @classmethod
     async def _fetch_page_dto(cls, page_id: str) -> NotionPageDto:
@@ -96,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
@@ -186,8 +124,12 @@ 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:
+        return MarkdownBuilder()
 
     async def get_comments(self) -> list[Comment]:
         return await self._comment_service.list_all_comments_for_page(page_id=self._id)