notionary 0.1.29__py3-none-any.whl → 0.2.1__py3-none-any.whl

notionary/page/relations/notion_page_relation_manager.py

@@ -1,16 +1,14 @@
+import asyncio
 from typing import Any, Dict, List, Optional
+from notionary.models.notion_page_response import DatabaseParent, NotionPageResponse
 from notionary.notion_client import NotionClient
 from notionary.page.relations.notion_page_title_resolver import (
     NotionPageTitleResolver,
 )
-from notionary.page.relations.relation_operation_result import (
-    RelationOperationResult,
-)
 from notionary.util.logging_mixin import LoggingMixin
-from notionary.util.page_id_utils import is_valid_uuid
 
 
-class NotionRelationManager(LoggingMixin):
+class NotionPageRelationManager(LoggingMixin):
     """
     Manager for relation properties of a Notion page.
     Manages links between pages and loads available relation options.
@@ -21,11 +19,6 @@ class NotionRelationManager(LoggingMixin):
     ):
         """
         Initializes the relation manager.
-
-        Args:
-            page_id: ID of the Notion page
-            client: NotionClient instance
-            database_id: Optional, ID of the database the page belongs to (loaded if needed)
         """
         self._page_id = page_id
         self._client = client
@@ -34,44 +27,6 @@ class NotionRelationManager(LoggingMixin):
 
         self._page_title_resolver = NotionPageTitleResolver(client=client)
 
-    async def _get_page_properties(self, force_refresh: bool = False) -> Dict[str, Any]:
-        """
-        Loads the properties of the page.
-
-        Args:
-            force_refresh: If True, a fresh API call will be made
-
-        Returns:
-            Dict[str, Any]: The properties of the page
-        """
-        if self._page_properties is None or force_refresh:
-            page_data = await self._client.get_page(self._page_id)
-            if page_data and "properties" in page_data:
-                self._page_properties = page_data["properties"]
-            else:
-                self._page_properties = {}
-
-        return self._page_properties
-
-    async def _ensure_database_id(self) -> Optional[str]:
-        """
-        Ensures the database_id is available. Loads it if necessary.
-
-        Returns:
-            Optional[str]: The database ID or None
-        """
-        if self._database_id:
-            return self._database_id
-
-        page_data = await self._client.get_page(self._page_id)
-        if page_data and "parent" in page_data:
-            parent = page_data["parent"]
-            if parent.get("type") == "database_id":
-                self._database_id = parent.get("database_id")
-                return self._database_id
-
-        return None
-
     async def get_relation_property_ids(self) -> List[str]:
         """
         Returns a list of all relation property names.
@@ -123,43 +78,6 @@ class NotionRelationManager(LoggingMixin):
 
         return titles
 
-    async def get_relation_details(
-        self, property_name: str
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Returns details about the relation property, including the linked database.
-
-        Args:
-            property_name: Name of the relation property
-
-        Returns:
-            Optional[Dict[str, Any]]: Relation details or None
-        """
-        database_id = await self._ensure_database_id()
-        if not database_id:
-            return None
-
-        try:
-            database = await self._client.get(f"databases/{database_id}")
-            if not database or "properties" not in database:
-                return None
-
-            properties = database["properties"]
-
-            if property_name not in properties:
-                return None
-
-            prop_data = properties[property_name]
-
-            if prop_data.get("type") != "relation":
-                return None
-
-            return prop_data.get("relation", {})
-
-        except Exception as e:
-            self.logger.error("Error retrieving relation details: %s", str(e))
-            return None
-
     async def get_relation_database_id(self, property_name: str) -> Optional[str]:
         """
         Returns the ID of the linked database for a relation property.
@@ -170,7 +88,7 @@ class NotionRelationManager(LoggingMixin):
         Returns:
             Optional[str]: ID of the linked database or None
         """
-        relation_details = await self.get_relation_details(property_name)
+        relation_details = await self._get_relation_details(property_name)
 
         if not relation_details:
             return None
@@ -179,16 +97,16 @@ class NotionRelationManager(LoggingMixin):
 
     async def get_relation_options(
         self, property_name: str, limit: int = 100
-    ) -> List[Dict[str, Any]]:
+    ) -> List[str]:
         """
-        Returns available options for a relation property.
+        Returns available title options for a relation property.
 
         Args:
             property_name: Name of the relation property
             limit: Maximum number of options to return
 
         Returns:
-            List[Dict[str, Any]]: List of available options with ID and name
+            List[str]: List of page titles that can be used for this relation
         """
         related_db_id = await self.get_relation_database_id(property_name)
 
@@ -206,193 +124,227 @@ class NotionRelationManager(LoggingMixin):
             if not query_result or "results" not in query_result:
                 return []
 
-            options = []
+            titles = []
             for page in query_result["results"]:
-                page_id = page.get("id")
                 title = self._extract_title_from_page(page)
+                if title:
+                    titles.append(title)
 
-                if page_id and title:
-                    options.append({"id": page_id, "name": title})
-
-            return options
+            return titles
         except Exception as e:
             self.logger.error("Error retrieving relation options: %s", str(e))
             return []
 
-    def _extract_title_from_page(self, page: Dict[str, Any]) -> Optional[str]:
+    async def set_relation_values_by_page_titles(
+        self, property_name: str, page_titles: List[str]
+    ) -> List[str]:
         """
-        Extracts the title from a page object.
+        Sets relation values based on page titles, replacing any existing relations.
 
         Args:
-            page: The page object from the Notion API
+            property_name: Name of the relation property
+            page_titles: List of page titles to set as relations
 
         Returns:
-            Optional[str]: The page title or None
+            List[str]: List of page titles that were successfully set as relations
         """
-        if "properties" not in page:
-            return None
+        self.logger.info(
+            "Setting %d relation(s) for property '%s'",
+            len(page_titles),
+            property_name,
+        )
 
-        properties = page["properties"]
+        resolution_results = await asyncio.gather(
+            *(
+                self._page_title_resolver.get_page_id_by_title(title)
+                for title in page_titles
+            )
+        )
 
-        for prop_data in properties.values():
-            if prop_data.get("type") == "title" and "title" in prop_data:
-                title_parts = prop_data["title"]
-                return "".join(
-                    [text_obj.get("plain_text", "") for text_obj in title_parts]
-                )
+        found_pages = []
+        page_ids = []
+        not_found_pages = []
 
-        return None
+        for title, page_id in zip(page_titles, resolution_results):
+            if page_id:
+                found_pages.append(title)
+                page_ids.append(page_id)
+                self.logger.debug("Found page ID %s for title '%s'", page_id, title)
+            else:
+                not_found_pages.append(title)
+                self.logger.warning("No page found with title '%s'", title)
 
-    async def add_relation(
-        self, property_name: str, page_ids: List[str]
+        self.logger.debug("Page IDs being sent to API: %s", page_ids)
+
+        if not page_ids:
+            self.logger.warning(
+                "No valid page IDs found for any of the titles, no changes applied"
+            )
+            return []
+
+        api_response = await self._set_relations_by_page_ids(property_name, page_ids)
+
+        if not api_response:
+            self.logger.error(
+                "Failed to set relations for '%s' (API error)", property_name
+            )
+            return []
+
+        if not_found_pages:
+            not_found_str = "', '".join(not_found_pages)
+            self.logger.info(
+                "Set %d relation(s) for '%s', but couldn't find pages: '%s'",
+                len(page_ids),
+                property_name,
+                not_found_str,
+            )
+        else:
+            self.logger.info(
+                "Successfully set all %d relation(s) for '%s'",
+                len(page_ids),
+                property_name,
+            )
+
+        return found_pages
+
+    async def get_all_relations(self) -> Dict[str, List[str]]:
+        """
+        Returns all relation properties and their values.
+
+        Returns:
+            Dict[str, List[str]]: Dictionary of property names and their values
+        """
+        relation_properties = await self.get_relation_property_ids()
+
+        if not relation_properties:
+            return {}
+
+        result = {}
+        for prop_name in relation_properties:
+            result[prop_name] = await self.get_relation_values(prop_name)
+
+        return result
+
+    async def _get_relation_details(
+        self, property_name: str
     ) -> Optional[Dict[str, Any]]:
         """
-        Adds one or more relations.
+        Returns details about the relation property, including the linked database.
 
         Args:
             property_name: Name of the relation property
-            page_ids: List of page IDs to add
 
         Returns:
-            Optional[Dict[str, Any]]: API response or None on error
+            The "relation" field of the property, or None if not found or not of type "relation".
         """
-        existing_relations = await self.get_relation_values(property_name) or []
+        database_id = await self._ensure_database_id()
+        if not database_id:
+            return None
 
-        all_relations = list(set(existing_relations + page_ids))
+        try:
+            database = await self._client.get_database(database_id)
 
-        relation_payload = {"relation": [{"id": page_id} for page_id in all_relations]}
+            prop_data = database.properties.get(property_name)
+            if not prop_data:
+                return None
 
-        try:
-            result = await self._client.patch(
-                f"pages/{self._page_id}",
-                {"properties": {property_name: relation_payload}},
-            )
+            if prop_data.get("type") != "relation":
+                return None
 
-            self._page_properties = None
+            return prop_data.get("relation")
 
-            return result
         except Exception as e:
-            self.logger.error("Error adding relation: %s", str(e))
+            self.logger.error("Error retrieving relation details: %s", str(e))
             return None
 
-    async def add_relation_by_name(
-        self, property_name: str, page_titles: List[str]
-    ) -> RelationOperationResult:
+    async def _get_page_properties(self, force_refresh: bool = False) -> Dict[str, Any]:
         """
-        Adds one or more relations based on page titles.
+        Loads the properties of the page.
 
         Args:
-            property_name: Name of the relation property
-            page_titles: List of page titles to link
+            force_refresh: If True, a new API call will be made.
 
         Returns:
-            RelationOperationResult: Result of the operation with details on which pages were found and added
+            Dict[str, Any]: The properties of the page.
         """
-        found_pages = []
-        not_found_pages = []
-        page_ids = []
+        if self._page_properties is None or force_refresh:
+            page_data = await self._client.get_page(self._page_id)
+            if page_data:
+                self._page_properties = page_data.properties or {}
+            else:
+                self._page_properties = {}
 
-        self.logger.info(
-            "Attempting to add %d relation(s) to property '%s'",
-            len(page_titles),
-            property_name,
-        )
+        return self._page_properties
 
-        for page in page_titles:
-            if is_valid_uuid(page):
-                page_ids.append(page)
-                found_pages.append(page)
-                self.logger.debug("Using page ID directly: %s", page)
-            else:
-                page_id = await self._page_title_resolver.get_page_id_by_title(page)
-                if page_id:
-                    page_ids.append(page_id)
-                    found_pages.append(page)
-                    self.logger.debug("Found page ID %s for title '%s'", page_id, page)
-                else:
-                    not_found_pages.append(page)
-                    self.logger.warning("No page found with title '%s'", page)
+    async def _ensure_database_id(self) -> Optional[str]:
+        """
+        Ensures the database_id is available. Loads it if necessary.
 
-        if not page_ids:
-            self.logger.warning(
-                "No valid page IDs found for any of the titles, no changes applied"
-            )
-            return RelationOperationResult.from_no_pages_found(
-                property_name, not_found_pages
-            )
+        Returns:
+            Optional[str]: The database ID or None
+        """
+        if self._database_id:
+            return self._database_id
 
-        api_response = await self.add_relation(property_name, page_ids)
+        page_data = await self._client.get_page(self._page_id)
 
-        if api_response:
-            result = RelationOperationResult.from_success(
-                property_name=property_name,
-                found_pages=found_pages,
-                not_found_pages=not_found_pages,
-                page_ids_added=page_ids,
-                api_response=api_response,
-            )
+        if not page_data or not page_data.parent:
+            return None
 
-            if not_found_pages:
-                not_found_str = "', '".join(not_found_pages)
-                self.logger.info(
-                    "Added %d relation(s) to '%s', but couldn't find pages: '%s'",
-                    len(page_ids),
-                    property_name,
-                    not_found_str,
-                )
-            else:
-                self.logger.info(
-                    "Successfully added all %d relation(s) to '%s'",
-                    len(page_ids),
-                    property_name,
-                )
+        if isinstance(page_data.parent, DatabaseParent):
+            self._database_id = page_data.parent.database_id
+            return self._database_id
 
-            return result
+        return None
 
-        self.logger.error("Failed to add relations to '%s' (API error)", property_name)
-        return RelationOperationResult.from_no_api_response(
-            property_name=property_name,
-            found_pages=found_pages,
-            page_ids_added=page_ids,
-        )
+    def _extract_title_from_page(self, page: Dict[str, Any]) -> Optional[str]:
+        """
+        Extracts the title from a page object.
 
-    async def set_relations(
+        Args:
+            page: The page object from the Notion API
+
+        Returns:
+            Optional[str]: The page title or None
+        """
+        if "properties" not in page:
+            return None
+
+        properties = page["properties"]
+
+        for prop_data in properties.values():
+            if prop_data.get("type") == "title" and "title" in prop_data:
+                title_parts = prop_data["title"]
+                return "".join(
+                    [text_obj.get("plain_text", "") for text_obj in title_parts]
+                )
+
+        return None
+
+    async def _set_relations_by_page_ids(
         self, property_name: str, page_ids: List[str]
-    ) -> Optional[Dict[str, Any]]:
+    ) -> Optional[NotionPageResponse]:
         """
-        Sets the relations to the specified IDs (replaces existing ones).
+        Adds one or more relations.
 
         Args:
             property_name: Name of the relation property
-            page_ids: List of page IDs to set
+            page_ids: List of page IDs to add
 
         Returns:
-            Optional[Dict[str, Any]]: API response or None on error
+            Optional[NotionPageResponse]: API response or None on error
         """
         relation_payload = {"relation": [{"id": page_id} for page_id in page_ids]}
 
         try:
-            result = await self._client.patch(
-                f"pages/{self._page_id}",
+            page_response: NotionPageResponse = await self._client.patch_page(
+                self._page_id,
                 {"properties": {property_name: relation_payload}},
             )
 
             self._page_properties = None
 
-            return result
+            return page_response
         except Exception as e:
-            self.logger.error("Error setting relations: %s", str(e))
+            self.logger.error("Error adding relation: %s", str(e))
             return None
-
-    async def get_all_relations(self) -> Dict[str, List[str]]:
-        """Returns all relation properties and their values."""
-        relation_properties = await self.get_relation_property_ids()
-
-        if not relation_properties:
-            return {}
-
-        result = {}
-        for prop_name in relation_properties:
-            result[prop_name] = await self.get_relation_values(prop_name)
-
-        return result

notionary/page/relations/notion_page_title_resolver.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, Dict, Any, List
 from notionary.notion_client import NotionClient
 from notionary.util.logging_mixin import LoggingMixin
 
@@ -17,39 +17,25 @@ class NotionPageTitleResolver(LoggingMixin):
                 {"query": title, "filter": {"value": "page", "property": "object"}},
             )
 
-            for result in search_results.get("results", []):
-                properties = result.get("properties", {})
-                if not properties:
-                    continue
-
-                for prop_value in properties.values():
-                    if prop_value.get("type") != "title":
-                        continue
-
-                    title_texts = prop_value.get("title", [])
-                    if not title_texts:
-                        continue
+            results = search_results.get("results", [])
 
-                    page_title = " ".join(
-                        [t.get("plain_text", "") for t in title_texts]
-                    )
+            if not results:
+                self.logger.debug(f"No page found with title '{title}'")
+                return None
 
-                    if not page_title:
-                        continue
+            # Durchsuche die Ergebnisse nach dem passenden Titel
+            for result in results:
+                properties = result.get("properties", {})
+                page_title = self._extract_page_title_from_properties(properties)
 
-                    if page_title == title or title in page_title:
-                        self.logger.debug(
-                            "Found page: '%s' with ID: %s",
-                            page_title,
-                            result.get("id"),
-                        )
-                        return result.get("id")
+                if page_title == title:
+                    return result.get("id")
 
-            self.logger.debug("No page found with title '%s'", title)
+            self.logger.debug(f"No matching page found with title '{title}'")
             return None
 
         except Exception as e:
-            self.logger.error("Error while searching for page '%s': %s", title, e)
+            self.logger.error(f"Error while searching for page '{title}': {e}")
             return None
 
     async def get_title_by_page_id(self, page_id: str) -> Optional[str]:
@@ -63,24 +49,56 @@ class NotionPageTitleResolver(LoggingMixin):
             The title of the page, or None if not found.
         """
         try:
-            page = await self._client.get(f"pages/{page_id}")
-            properties = page.get("properties", {})
+            page = await self._client.get_page(page_id)
+            return self._extract_page_title_from_properties(page.properties)
 
-            for prop in properties.values():
-                if prop.get("type") != "title":
-                    continue
+        except Exception as e:
+            self.logger.error(f"Error retrieving title for page ID '{page_id}': {e}")
+            return None
+
+    async def get_page_titles_by_ids(self, page_ids: List[str]) -> Dict[str, str]:
+        """
+        Retrieves titles for multiple page IDs at once.
+
+        Args:
+            page_ids: List of page IDs to get titles for
+
+        Returns:
+            Dictionary mapping page IDs to their titles
+        """
+        result = {}
+        for page_id in page_ids:
+            title = await self.get_title_by_page_id(page_id)
+            if title:
+                result[page_id] = title
+        return result
+
+    def _extract_page_title_from_properties(self, properties: Dict[str, Any]) -> str:
+        """
+        Extract title from properties dictionary.
 
-                title_parts = prop.get("title", [])
-                if not title_parts:
+        Args:
+            properties: The properties dictionary from a Notion page
+
+        Returns:
+            str: The extracted title or "Untitled" if not found
+        """
+        try:
+            for prop_value in properties.values():
+                if not isinstance(prop_value, dict):
                     continue
 
-                title = " ".join([t.get("plain_text", "") for t in title_parts])
-                if title:
-                    return title
+                if prop_value.get("type") != "title":
+                    continue
 
-            self.logger.debug("No title found for page ID '%s'", page_id)
-            return None
+                title_array = prop_value.get("title", [])
+                if not title_array:
+                    continue
 
+                for text_obj in title_array:
+                    if "plain_text" in text_obj:
+                        return text_obj["plain_text"]
         except Exception as e:
-            self.logger.error("Error retrieving title for page ID '%s': %s", page_id, e)
-            return None
+            self.logger.error(f"Error extracting page title from properties: {e}")
+
+        return "Untitled"

notionary/page/relations/page_database_relation.py

@@ -1,4 +1,5 @@
 from typing import Dict, Optional, Any
+from notionary.models.notion_page_response import DatabaseParent, NotionPageResponse
 from notionary.notion_client import NotionClient
 from notionary.util.logging_mixin import LoggingMixin
 
@@ -23,7 +24,7 @@ class PageDatabaseRelation(LoggingMixin):
         self._database_schema = None
         self._page_data = None
 
-    async def _get_page_data(self, force_refresh=False) -> Dict[str, Any]:
+    async def _get_page_data(self, force_refresh=False) -> NotionPageResponse:
         """
         Gets the page data and caches it for future use.
 
@@ -39,22 +40,19 @@ class PageDatabaseRelation(LoggingMixin):
 
     async def get_parent_database_id(self) -> Optional[str]:
         """
-        Gets the ID of the database this page belongs to, if any.
-
-        Returns:
-            Optional[str]: The database ID or None if the page doesn't belong to a database
+        Returns the ID of the database this page belongs to, if any.
         """
         if self._parent_database_id is not None:
             return self._parent_database_id
 
         page_data = await self._get_page_data()
 
-        if not page_data or "parent" not in page_data:
+        if not page_data:
             return None
 
-        parent = page_data.get("parent", {})
-        if parent.get("type") == "database_id":
-            self._parent_database_id = parent.get("database_id")
+        parent = page_data.parent
+        if isinstance(parent, DatabaseParent):
+            self._parent_database_id = parent.database_id
             return self._parent_database_id
 
         return None