notionary 0.2.12__py3-none-any.whl → 0.2.14__py3-none-any.whl

notionary/page/notion_page.py

@@ -1,29 +1,24 @@
 from __future__ import annotations
-from typing import Any, Dict, List, Optional
-import re
-
-from notionary.elements.registry.block_registry import BlockRegistry
-from notionary.elements.registry.block_registry_builder import BlockRegistryBuilder
-from notionary.notion_client import NotionClient
+import asyncio
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+import random
+
+from notionary.blocks import BlockRegistry, BlockRegistryBuilder
+from notionary.models.notion_database_response import NotionPageResponse
+from notionary.models.notion_page_response import DatabaseParent
+from notionary.page.client import NotionPageClient
 from notionary.page.content.page_content_retriever import PageContentRetriever
-from notionary.page.metadata.metadata_editor import MetadataEditor
-from notionary.page.metadata.notion_icon_manager import NotionPageIconManager
-from notionary.page.metadata.notion_page_cover_manager import (
-    NotionPageCoverManager,
-)
-from notionary.page.properites.database_property_service import (
-    DatabasePropertyService,
-)
-from notionary.page.relations.notion_page_relation_manager import (
-    NotionPageRelationManager,
-)
+
+
 from notionary.page.content.page_content_writer import PageContentWriter
-from notionary.page.properites.page_property_manager import PagePropertyManager
-from notionary.page.relations.notion_page_title_resolver import NotionPageTitleResolver
-from notionary.util.warn_direct_constructor_usage import warn_direct_constructor_usage
-from notionary.util import LoggingMixin
-from notionary.util.page_id_utils import extract_and_validate_page_id
-from notionary.page.relations.page_database_relation import PageDatabaseRelation
+from notionary.page.property_formatter import NotionPropertyFormatter
+from notionary.page.utils import extract_property_value
+
+from notionary.util import LoggingMixin, format_uuid, FuzzyMatcher, factory_only
+
+
+if TYPE_CHECKING:
+    from notionary import NotionDatabase
 
 
 class NotionPage(LoggingMixin):
@@ -31,21 +26,29 @@ class NotionPage(LoggingMixin):
     Managing content and metadata of a Notion page.
     """
 
-    @warn_direct_constructor_usage
+    @factory_only("from_page_id", "from_page_name")
     def __init__(
         self,
-        page_id: Optional[str] = None,
-        title: Optional[str] = None,
-        url: Optional[str] = None,
+        page_id: str,
+        title: str,
+        url: str,
+        emoji_icon: Optional[str] = None,
+        properties: Optional[Dict[str, Any]] = None,
+        parent_database: Optional[NotionDatabase] = None,
         token: Optional[str] = None,
     ):
-        self._page_id = extract_and_validate_page_id(page_id=page_id, url=url)
-        self._url = url
+        """
+        Initialize the page manager with all metadata.
+        """
+        self._page_id = page_id
         self._title = title
-        self._client = NotionClient(token=token)
+        self._url = url
+        self._emoji_icon = emoji_icon
+        self._properties = properties
+        self._parent_database = parent_database
+
+        self._client = NotionPageClient(token=token)
         self._page_data = None
-        self._title_loaded = title is not None
-        self._url_loaded = url is not None
 
         self._block_element_registry = BlockRegistryBuilder.create_full_registry()
 
@@ -57,83 +60,76 @@ class NotionPage(LoggingMixin):
 
         self._page_content_retriever = PageContentRetriever(
             page_id=self._page_id,
-            client=self._client,
             block_registry=self._block_element_registry,
         )
 
-        self._metadata = MetadataEditor(self._page_id, self._client)
-        self._page_cover_manager = NotionPageCoverManager(
-            page_id=self._page_id, client=self._client
-        )
-        self._page_icon_manager = NotionPageIconManager(
-            page_id=self._page_id, client=self._client
-        )
-
-        self._db_relation = PageDatabaseRelation(
-            page_id=self._page_id, client=self._client
-        )
-        self._db_property_service = None
-
-        self._relation_manager = NotionPageRelationManager(
-            page_id=self._page_id, client=self._client
-        )
-
-        self._property_manager = PagePropertyManager(
-            self._page_id, self._client, self._metadata, self._db_relation
-        )
-
     @classmethod
-    def from_page_id(cls, page_id: str, token: Optional[str] = None) -> NotionPage:
+    async def from_page_id(
+        cls, page_id: str, token: Optional[str] = None
+    ) -> NotionPage:
         """
         Create a NotionPage from a page ID.
 
         Args:
             page_id: The ID of the Notion page
             token: Optional Notion API token (uses environment variable if not provided)
-
-        Returns:
-            An initialized NotionPage instance
         """
-        from notionary.page.notion_page_factory import NotionPageFactory
+        formatted_id = format_uuid(page_id) or page_id
 
-        cls.logger.info("Creating page from ID: %s", page_id)
-        return NotionPageFactory().from_page_id(page_id, token)
+        async with NotionPageClient(token=token) as client:
+            page_response = await client.get_page(formatted_id)
+            return await cls._create_from_response(page_response, token)
 
     @classmethod
-    def from_url(cls, url: str, token: Optional[str] = None) -> NotionPage:
+    async def from_page_name(
+        cls, page_name: str, token: Optional[str] = None, min_similarity: float = 0.6
+    ) -> NotionPage:
         """
-        Create a NotionPage from a Notion URL.
-
-        Args:
-            url: The URL of the Notion page
-            token: Optional Notion API token (uses environment variable if not provided)
-
-        Returns:
-            An initialized NotionPage instance
+        Create a NotionPage by finding a page with fuzzy matching on the title.
+        Uses Notion's search API and fuzzy matching to find the best result.
         """
-        from notionary.page.notion_page_factory import NotionPageFactory
+        from notionary.workspace import NotionWorkspace
 
-        cls.logger.info("Creating page from URL: %s", url)
-        return NotionPageFactory().from_url(url, token)
+        workspace = NotionWorkspace()
 
-    @classmethod
-    async def from_page_name(
-        cls, page_name: str, token: Optional[str] = None
-    ) -> NotionPage:
-        """
-        Create a NotionPage by finding a page with a matching name.
-        Uses fuzzy matching to find the closest match to the given name.
+        try:
+            search_results: List[NotionPage] = await workspace.search_pages(
+                page_name, limit=10
+            )
 
-        Args:
-            page_name: The name of the Notion page to search for
-            token: Optional Notion API token (uses environment variable if not provided)
+            if not search_results:
+                cls.logger.warning("No pages found for name: %s", page_name)
+                raise ValueError(f"No pages found for name: {page_name}")
 
-        Returns:
-            An initialized NotionPage instance
-        """
-        from notionary.page.notion_page_factory import NotionPageFactory
+            best_match = FuzzyMatcher.find_best_match(
+                query=page_name,
+                items=search_results,
+                text_extractor=lambda page: page.title,
+                min_similarity=min_similarity,
+            )
+
+            if not best_match:
+                available_titles = [result.title for result in search_results[:5]]
+                cls.logger.warning(
+                    "No sufficiently similar page found for '%s' (min: %.3f). Available: %s",
+                    page_name,
+                    min_similarity,
+                    available_titles,
+                )
+                raise ValueError(
+                    f"No sufficiently similar page found for '{page_name}'"
+                )
+
+            async with NotionPageClient(token=token) as client:
+                page_response = await client.get_page(page_id=best_match.item.id)
+                instance = await cls._create_from_response(
+                    page_response=page_response, token=token
+                )
+                return instance
 
-        return await NotionPageFactory().from_page_name(page_name, token)
+        except Exception as e:
+            cls.logger.error("Error finding page by name: %s", str(e))
+            raise
 
     @property
     def id(self) -> str:
@@ -143,40 +139,43 @@ class NotionPage(LoggingMixin):
         return self._page_id
 
     @property
-    def block_registry(self) -> BlockRegistry:
+    def title(self) -> str:
         """
-        Get the block element registry associated with this page.
+        Get the title of the page.
+        """
+        return self._title
 
-        Returns:
-            BlockElementRegistry: The registry of block elements.
+    @property
+    def url(self) -> str:
         """
-        return self._block_element_registry
+        Get the URL of the page.
+        If not set, generate it from the title and ID.
+        """
+        return self._url
 
     @property
-    def block_registry_builder(self) -> BlockRegistryBuilder:
+    def emoji_icon(self) -> Optional[str]:
+        """
+        Get the emoji icon of the page.
         """
-        Get the block element registry builder associated with this page.
+        return self._emoji_icon
 
-        Returns:
-            BlockElementRegistryBuilder: The builder for block elements.
+    @property
+    def properties(self) -> Optional[Dict[str, Any]]:
+        """
+        Get the properties of the page.
         """
-        return self._block_element_registry.builder
+        return self._properties
 
-    @block_registry.setter
-    def block_registry(self, block_registry: BlockRegistry) -> None:
+    @property
+    def block_registry(self) -> BlockRegistry:
         """
-        Set the block element registry for the page content manager.
+        Get the block element registry associated with this page.
 
-        Args:
-            block_registry: The registry of block elements to use.
+        Returns:
+            BlockElementRegistry: The registry of block elements.
         """
-        self._block_element_registry = block_registry
-        self._page_content_writer = PageContentWriter(
-            page_id=self._page_id, client=self._client, block_registry=block_registry
-        )
-        self._page_content_retriever = PageContentRetriever(
-            page_id=self._page_id, client=self._client, block_registry=block_registry
-        )
+        return self._block_element_registry
 
     def get_notion_markdown_system_prompt(self) -> str:
         """
@@ -187,54 +186,29 @@ class NotionPage(LoggingMixin):
         """
         return self._block_element_registry.get_notion_markdown_syntax_prompt()
 
-    async def get_title(self) -> str:
-        """
-        Get the title of the page, loading it if necessary.
-
-        Returns:
-            str: The page title.
-        """
-        if not self._title_loaded:
-            self._title = await self._fetch_page_title()
-        return self._title
-
-    async def set_title(self, title: str) -> Optional[Dict[str, Any]]:
+    async def set_title(self, title: str) -> str:
         """
         Set the title of the page.
+        """
+        try:
+            data = {
+                "properties": {
+                    "title": {"title": [{"type": "text", "text": {"content": title}}]}
+                }
+            }
 
-        Args:
-            title: The new title.
+            await self._client.patch_page(self._page_id, data)
 
-        Returns:
-            Optional[Dict[str, Any]]: Response data from the API if successful, None otherwise.
-        """
-        result = await self._metadata.set_title(title)
-        if result:
             self._title = title
-            self._title_loaded = True
-        return result
+            return title
 
-    async def get_url(self) -> str:
-        """
-        Get the URL of the page, constructing it if necessary.
-
-        Returns:
-            str: The page URL.
-        """
-        if not self._url_loaded:
-            self._url = await self._generate_url_from_title()
-            self._url_loaded = True
-        return self._url
+        except Exception as e:
+            self.logger.error("Error setting page title: %s", str(e))
+            return None
 
     async def append_markdown(self, markdown: str, append_divider=False) -> bool:
         """
         Append markdown content to the page.
-
-        Args:
-            markdown: The markdown content to append.
-
-        Returns:
-            str: Status or confirmation message.
         """
         return await self._page_content_writer.append_markdown(
             markdown_text=markdown, append_divider=append_divider
@@ -243,9 +217,6 @@ class NotionPage(LoggingMixin):
     async def clear_page_content(self) -> bool:
         """
         Clear all content from the page.
-
-        Returns:
-            str: Status or confirmation message.
         """
         return await self._page_content_writer.clear_page_content()
 
@@ -277,251 +248,317 @@ class NotionPage(LoggingMixin):
         """
         return await self._page_content_retriever.get_page_content()
 
-    async def get_icon(self) -> str:
-        """
-        Retrieve the page icon - either emoji or external URL.
-
-        Returns:
-            Optional[str]: The icon emoji or URL, or None if no icon is set.
-        """
-        return await self._page_icon_manager.get_icon()
-
     async def set_emoji_icon(self, emoji: str) -> Optional[str]:
         """
         Sets the page icon to an emoji.
+        """
+        try:
+            icon = {"type": "emoji", "emoji": emoji}
+            page_response = await self._client.patch_page(
+                page_id=self._page_id, data={"icon": icon}
+            )
 
-        Args:
-            emoji (str): The emoji character to set as the icon.
+            self._emoji = page_response.icon.emoji
+            return page_response.icon.emoji
+        except Exception as e:
 
-        Returns:
-            Optional[Dict[str, Any]]: Response data from the API if successful, None otherwise.
-        """
-        return await self._page_icon_manager.set_emoji_icon(emoji=emoji)
+            self.logger.error(f"Error updating page emoji: {str(e)}")
+            return None
 
     async def set_external_icon(self, url: str) -> Optional[str]:
         """
         Sets the page icon to an external image.
+        """
+        try:
+            icon = {"type": "external", "external": {"url": url}}
+            page_response = await self._client.patch_page(
+                page_id=self._page_id, data={"icon": icon}
+            )
 
-        Args:
-            url (str): The URL of the external image to set as the icon.
+            # For external icons, we clear the emoji since we now have external icon
+            self._emoji = None
+            self.logger.info(f"Successfully updated page external icon to: {url}")
+            return page_response.icon.external.url
 
-        Returns:
-            Optional[Dict[str, Any]]: Response data from the API if successful, None otherwise.
-        """
-        return await self._page_icon_manager.set_external_icon(external_icon_url=url)
+        except Exception as e:
+            self.logger.error(f"Error updating page external icon: {str(e)}")
+            return None
 
     async def get_cover_url(self) -> Optional[str]:
         """
         Get the URL of the page cover image.
-
-        Returns:
-            str: The URL of the cover image or empty string if not available.
         """
-        return await self._page_cover_manager.get_cover_url()
+        try:
+            page_data = await self._client.get_page(self.id)
+            if not page_data or not page_data.cover:
+                return None
+            if page_data.cover.type == "external":
+                return page_data.cover.external.url
+        except Exception as e:
+            self.logger.error(f"Error fetching cover URL: {str(e)}")
+            return None
 
     async def set_cover(self, external_url: str) -> Optional[str]:
         """
         Set the cover image for the page using an external URL.
-
-        Args:
-            external_url: URL to the external image.
-
-        Returns:
-            Optional[Dict[str, Any]]: Response data from the API if successful, None otherwise.
         """
-        return await self._page_cover_manager.set_cover(external_url)
+        data = {"cover": {"type": "external", "external": {"url": external_url}}}
+        try:
+            updated_page = await self._client.patch_page(self.id, data=data)
+            return updated_page.cover.external.url
+        except Exception as e:
+            self.logger.error("Failed to set cover image: %s", str(e))
+            return None
 
-    async def set_random_gradient_cover(self) -> Optional[Dict[str, Any]]:
+    async def set_random_gradient_cover(self) -> Optional[str]:
         """
         Set a random gradient as the page cover.
-
-        Returns:
-            Optional[Dict[str, Any]]: Response data from the API if successful, None otherwise.
         """
-        return await self._page_cover_manager.set_random_gradient_cover()
+        default_notion_covers = [
+            f"https://www.notion.so/images/page-cover/gradients_{i}.png"
+            for i in range(1, 10)
+        ]
+        random_cover_url = random.choice(default_notion_covers)
+        return await self.set_cover(random_cover_url)
 
     async def get_property_value_by_name(self, property_name: str) -> Any:
         """
         Get the value of a specific property.
-
-        Args:
-            property_name: The name of the property.
-
-        Returns:
-            Any: The value of the property.
         """
-        properties = await self._property_manager._get_properties()
+        if not self._parent_database:
+            return None
+
+        database_property_schema = self._parent_database.properties.get(property_name)
 
-        if property_name not in properties:
+        if not database_property_schema:
+            self.logger.warning(
+                "Property '%s' not found in database schema", property_name
+            )
             return None
 
-        prop_data = properties[property_name]
-        prop_type = prop_data.get("type")
+        property_type = database_property_schema.get("type")
 
-        if prop_type == "relation":
-            return await self._relation_manager.get_relation_values(property_name)
+        if property_type == "relation":
+            return await self._get_relation_property_values_by_name(property_name)
+
+        if property_name not in self._properties:
+            self.logger.warning(
+                "Property '%s' not found in page properties", property_name
+            )
+            return None
 
-        return await self._property_manager.get_property_value(property_name)
+        property_data = self._properties.get(property_name)
+        return extract_property_value(property_data)
 
-    async def get_options_for_property(
-        self, property_name: str, limit: int = 100
+    async def _get_relation_property_values_by_name(
+        self, property_name: str
     ) -> List[str]:
         """
-        Get the available options for a property (select, multi_select, status, relation).
-
-        Args:
-            property_name: The name of the property.
-            limit: Maximum number of options to return (only affects relation properties).
-
-        Returns:
-            List[str]: List of available option names or page titles.
+        Retrieve the titles of all related pages for a relation property.
         """
-        property_type = await self._get_property_type(property_name)
+        page_property_schema = self.properties.get(property_name)
+        relation_page_ids = [
+            rel.get("id") for rel in page_property_schema.get("relation", [])
+        ]
+        notion_pages = [
+            await NotionPage.from_page_id(page_id) for page_id in relation_page_ids
+        ]
+        return [page.title for page in notion_pages if page]
 
-        if property_type is None:
+    async def get_options_for_property_by_name(self, property_name: str) -> List[str]:
+        """
+        Get the available options for a property (select, multi_select, status, relation).
+        """
+        if not self._parent_database:
+            self.logger.error(
+                "Parent database not set. Cannot get options for property: %s",
+                property_name,
+            )
             return []
 
-        if property_type == "relation":
-            return await self._relation_manager.get_relation_options(
-                property_name, limit
+        try:
+            return await self._parent_database.get_options_by_property_name(
+                property_name=property_name
             )
+        except Exception as e:
+            self.logger.error(
+                "Error getting options for property '%s': %s", property_name, str(e)
+            )
+            return []
 
-        db_service = await self._get_db_property_service()
-        if db_service:
-            return await db_service.get_option_names(property_name)
-
-        return []
-
-    async def set_property_value_by_name(
-        self, property_name: str, value: Any
-    ) -> Optional[Dict[str, Any]]:
+    # Diese Methode hier sollte auch für relation properties funktionieren aber gerne auch eine dedizierte hier
+    async def set_property_value_by_name(self, property_name: str, value: Any) -> Any:
         """
         Set the value of a specific property by its name.
+        """
+        if not self._parent_database:
+            return None
 
-        Args:
-            property_name: The name of the property.
-            value: The new value to set.
+        property_type = self._parent_database.properties.get(property_name).get("type")
 
-        Returns:
-            Optional[Dict[str, Any]]: Response data from the API if successful, None otherwise.
-        """
-        return await self._property_manager.set_property_by_name(
-            property_name=property_name,
-            value=value,
+        if not property_type:
+            return None
+
+        if property_type == "relation":
+            return await self.set_relation_property_values_by_name(
+                property_name=property_name, page_titles=value
+            )
+
+        property_formatter = NotionPropertyFormatter()
+        update_data = property_formatter.format_value(
+            property_name=property_name, property_type=property_type, value=value
         )
 
+        try:
+            updated_page_response = await self._client.patch_page(
+                page_id=self._page_id, data=update_data
+            )
+            self._properties = updated_page_response.properties
+            return extract_property_value(self._properties.get(property_name))
+        except Exception as e:
+            self.logger.error(
+                "Error setting property '%s' to value '%s': %s",
+                property_name,
+                value,
+                str(e),
+            )
+            return None
+
     async def set_relation_property_values_by_name(
-        self, relation_property_name: str, page_titles: List[str]
+        self, property_name: str, page_titles: List[str]
     ) -> List[str]:
         """
         Add one or more relations to a relation property.
+        """
+        if not self._parent_database:
+            return []
 
-        Args:
-            relation_property_name: The name of the relation property.
-            page_titles: A list of page titles to relate to.
+        property_type = self._parent_database.properties.get(property_name).get("type")
 
-        Returns:
-            Optional[Dict[str, Any]]: Response data from the API if successful, None otherwise.
-        """
-        return await self._relation_manager.set_relation_values_by_page_titles(
-            property_name=relation_property_name, page_titles=page_titles
+        # for direct calls
+        if property_type != "relation":
+            return []
+
+        relation_pages = await asyncio.gather(
+            *(
+                NotionPage.from_page_name(page_name=page_title)
+                for page_title in page_titles
+            )
         )
 
-    async def get_relation_property_values_by_name(
-        self, property_name: str
-    ) -> List[str]:
-        """
-        Return the current relation values for a property.
+        relation_page_ids = [page.id for page in relation_pages]
 
-        Args:
-            property_name: The name of the relation property.
+        property_formatter = NotionPropertyFormatter()
 
-        Returns:
-            List[str]: List of relation values.
-        """
-        return await self._relation_manager.get_relation_values(property_name)
-
-    async def get_last_edit_time(self) -> str:
-        """
-        Get the timestamp when the page was last edited.
+        update_data = property_formatter.format_value(
+            property_name=property_name,
+            property_type="relation",
+            value=relation_page_ids,
+        )
 
-        Returns:
-            str: ISO 8601 formatted timestamp string of when the page was last edited.
-        """
         try:
-            page_response = await self._client.get_page(self._page_id)
-            return (
-                page_response.last_edited_time if page_response.last_edited_by else ""
+            updated_page_response = await self._client.patch_page(
+                page_id=self._page_id, data=update_data
             )
-
+            self._properties = updated_page_response.properties
+            return page_titles
         except Exception as e:
-            self.logger.error("Error retrieving last edited time: %s", str(e))
-            return ""
+            self.logger.error(
+                "Error setting property '%s' to value '%s': %s",
+                property_name,
+                page_titles,
+                str(e),
+            )
+            return []
 
-    async def _fetch_page_title(self) -> str:
+    async def archive(self) -> bool:
         """
-        Load the page title from Notion API if not already loaded.
-
-        Returns:
-            str: The page title.
+        Archive the page by moving it to the trash.
         """
-        notion_page_title_resolver = NotionPageTitleResolver(self._client)
-        return await notion_page_title_resolver.get_title_by_page_id(
-            page_id=self._page_id
-        )
+        try:
+            result = await self._client.patch_page(
+                page_id=self._page_id, data={"archived": True}
+            )
+            return result is not None
+        except Exception as e:
+            self.logger.error("Error archiving page %s: %s", self._page_id, str(e))
+            return False
 
-    async def _generate_url_from_title(self) -> str:
+    @classmethod
+    async def _create_from_response(
+        cls,
+        page_response: NotionPageResponse,
+        token: Optional[str],
+    ) -> NotionPage:
         """
-        Build a Notion URL from the page ID, including the title if available.
-
-        Returns:
-            str: The Notion URL for the page.
+        Create NotionPage instance from API response.
         """
-        title = await self._fetch_page_title()
+        from notionary.database.notion_database import NotionDatabase
 
-        url_title = ""
-        if title and title != "Untitled":
-            url_title = re.sub(r"[^\w\s-]", "", title)
-            url_title = re.sub(r"[\s]+", "-", url_title)
-            url_title = f"{url_title}-"
+        title = cls._extract_title(page_response)
+        emoji = cls._extract_emoji(page_response)
+        parent_database_id = cls._extract_parent_database_id(page_response)
 
-        clean_id = self._page_id.replace("-", "")
-
-        return f"https://www.notion.so/{url_title}{clean_id}"
+        parent_database = (
+            await NotionDatabase.from_database_id(
+                database_id=parent_database_id, token=token
+            )
+            if parent_database_id
+            else None
+        )
 
-    async def _get_db_property_service(self) -> Optional[DatabasePropertyService]:
-        """
-        Gets the database property service, initializing it if necessary.
-        This is a more intuitive way to work with the instance variable.
+        instance = cls(
+            page_id=page_response.id,
+            title=title,
+            url=page_response.url,
+            emoji_icon=emoji,
+            properties=page_response.properties,
+            parent_database=parent_database,
+            token=token,
+        )
 
-        Returns:
-            Optional[DatabasePropertyService]: The database property service or None if not applicable
-        """
-        if self._db_property_service is not None:
-            return self._db_property_service
+        cls.logger.info("Created page manager: '%s' (ID: %s)", title, page_response.id)
+        return instance
 
-        database_id = await self._db_relation.get_parent_database_id()
-        if not database_id:
-            return None
+    @staticmethod
+    def _extract_title(page_response: NotionPageResponse) -> str:
+        """Extract title from page response. Returns empty string if not found."""
 
-        self._db_property_service = DatabasePropertyService(database_id, self._client)
-        await self._db_property_service.load_schema()
-        return self._db_property_service
+        if not page_response.properties:
+            return ""
 
-    async def _get_property_type(self, property_name: str) -> Optional[str]:
-        """
-        Get the type of a specific property.
+        title_property = next(
+            (
+                prop
+                for prop in page_response.properties.values()
+                if isinstance(prop, dict) and prop.get("type") == "title"
+            ),
+            None,
+        )
 
-        Args:
-            property_name: The name of the property.
+        if not title_property or "title" not in title_property:
+            return ""
 
-        Returns:
-            Optional[str]: The type of the property, or None if not found.
-        """
-        properties = await self._property_manager._get_properties()
+        try:
+            title_parts = title_property["title"]
+            return "".join(part.get("plain_text", "") for part in title_parts)
+        except (KeyError, TypeError, AttributeError):
+            return ""
 
-        if property_name not in properties:
+    @staticmethod
+    def _extract_emoji(page_response: NotionPageResponse) -> Optional[str]:
+        """Extract emoji from database response."""
+        if not page_response.icon:
             return None
 
-        prop_data = properties[property_name]
-        return prop_data.get("type")
+        if page_response.icon.type == "emoji":
+            return page_response.icon.emoji
+
+        return None
+
+    @staticmethod
+    def _extract_parent_database_id(page_response: NotionPageResponse) -> Optional[str]:
+        """Extract parent database ID from page response."""
+        parent = page_response.parent
+        if isinstance(parent, DatabaseParent):
+            return parent.database_id