notionary 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

notionary/core/page/properites/property_operation_result.py

@@ -1,11 +1,12 @@
 from typing import Any, Dict, List, Optional
 from dataclasses import dataclass
 
+
 @dataclass
 class PropertyOperationResult:
     """
     Result of a property operation in Notion.
-    
+
     Attributes:
         success: Whether the operation was successful
         property_name: Name of the affected property
@@ -14,90 +15,102 @@ class PropertyOperationResult:
         available_options: Available options for select-like properties
         api_response: The original API response
     """
+
     success: bool
     property_name: str
     value: Optional[Any] = None
     error: Optional[str] = None
     available_options: Optional[List[str]] = None
     api_response: Optional[Dict[str, Any]] = None
-    
+
     # Common error messages
     NO_API_RESPONSE = "Failed to set property (no API response)"
     RELATION_TYPE_ERROR = "Property '{}' is of type 'relation'. Relations must be set using the RelationManager."
-    
+
     @classmethod
-    def from_success(cls, property_name: str, value: Any, api_response: Dict[str, Any]) -> "PropertyOperationResult":
+    def from_success(
+        cls, property_name: str, value: Any, api_response: Dict[str, Any]
+    ) -> "PropertyOperationResult":
         """Creates a success result."""
         return cls(
-            success=True, 
-            property_name=property_name, 
-            value=value, 
-            api_response=api_response
+            success=True,
+            property_name=property_name,
+            value=value,
+            api_response=api_response,
         )
-    
+
     @classmethod
-    def from_error(cls, property_name: str, 
-                   error: str, 
-                   value: Optional[Any] = None, 
-                   available_options: Optional[List[str]] = None) -> "PropertyOperationResult":
+    def from_error(
+        cls,
+        property_name: str,
+        error: str,
+        value: Optional[Any] = None,
+        available_options: Optional[List[str]] = None,
+    ) -> "PropertyOperationResult":
         """Creates an error result."""
         return cls(
             success=False,
             property_name=property_name,
             value=value,
             error=error,
-            available_options=available_options or []
+            available_options=available_options or [],
         )
-    
+
     @classmethod
-    def from_api_error(cls, property_name: str, api_response: Dict[str, Any]) -> "PropertyOperationResult":
+    def from_api_error(
+        cls, property_name: str, api_response: Dict[str, Any]
+    ) -> "PropertyOperationResult":
         """Creates a result from an API error response."""
         return cls(
             success=False,
             property_name=property_name,
             error=api_response.get("message", "Unknown API error"),
-            api_response=api_response
+            api_response=api_response,
         )
-        
+
     @classmethod
-    def from_no_api_response(cls, property_name: str, value: Optional[Any] = None) -> "PropertyOperationResult":
+    def from_no_api_response(
+        cls, property_name: str, value: Optional[Any] = None
+    ) -> "PropertyOperationResult":
         """Creates a standardized result for missing API responses."""
         return cls.from_error(property_name, cls.NO_API_RESPONSE, value)
 
     @classmethod
-    def from_relation_type_error(cls, property_name: str, value: Optional[Any] = None) -> "PropertyOperationResult":
+    def from_relation_type_error(
+        cls, property_name: str, value: Optional[Any] = None
+    ) -> "PropertyOperationResult":
         """Creates a standardized error result for relation type properties."""
         error_msg = cls.RELATION_TYPE_ERROR.format(property_name)
         return cls.from_error(property_name, error_msg, value)
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """Converts the result to a dictionary."""
         result = {
             "success": self.success,
             "property": self.property_name,
         }
-        
+
         if self.value is not None:
             result["value"] = self.value
-        
+
         if not self.success:
             result["error"] = self.error
-            
+
             if self.available_options:
                 result["available_options"] = self.available_options
-                
+
         if self.api_response:
             result["api_response"] = self.api_response
-            
+
         return result
-    
+
     def __str__(self) -> str:
         """String representation of the result."""
         if self.success:
             return f"Success: Property '{self.property_name}' set to '{self.value}'"
-        
+
         if self.available_options:
             options = "', '".join(self.available_options)
             return f"Error: {self.error}\nAvailable options for '{self.property_name}': '{options}'"
-        
-        return f"Error: {self.error}"
+
+        return f"Error: {self.error}"

notionary/core/page/properites/property_value_extractor.py

@@ -10,19 +10,33 @@ class PropertyValueExtractor:
         self,
         property_name: str,
         prop_data: dict,
-        relation_resolver: Callable[[str], Awaitable[Any]]
+        relation_resolver: Callable[[str], Awaitable[Any]],
     ) -> Any:
         prop_type = prop_data.get("type")
         if not prop_type:
             return None
 
         handlers: dict[str, Callable[[], Awaitable[Any] | Any]] = {
-            "title": lambda: "".join(t.get("plain_text", "") for t in prop_data.get("title", [])),
-            "rich_text": lambda: "".join(t.get("plain_text", "") for t in prop_data.get("rich_text", [])),
+            "title": lambda: "".join(
+                t.get("plain_text", "") for t in prop_data.get("title", [])
+            ),
+            "rich_text": lambda: "".join(
+                t.get("plain_text", "") for t in prop_data.get("rich_text", [])
+            ),
             "number": lambda: prop_data.get("number"),
-            "select": lambda: prop_data.get("select", {}).get("name") if prop_data.get("select") else None,
-            "multi_select": lambda: [o.get("name") for o in prop_data.get("multi_select", [])],
-            "status": lambda: prop_data.get("status", {}).get("name") if prop_data.get("status") else None,
+            "select": lambda: (
+                prop_data.get("select", {}).get("name")
+                if prop_data.get("select")
+                else None
+            ),
+            "multi_select": lambda: [
+                o.get("name") for o in prop_data.get("multi_select", [])
+            ],
+            "status": lambda: (
+                prop_data.get("status", {}).get("name")
+                if prop_data.get("status")
+                else None
+            ),
             "date": lambda: prop_data.get("date"),
             "checkbox": lambda: prop_data.get("checkbox"),
             "url": lambda: prop_data.get("url"),
@@ -31,9 +45,13 @@ class PropertyValueExtractor:
             "relation": lambda: relation_resolver(property_name),
             "people": lambda: [p.get("id") for p in prop_data.get("people", [])],
             "files": lambda: [
-                f.get("external", {}).get("url") if f.get("type") == "external" else f.get("name")
+                (
+                    f.get("external", {}).get("url")
+                    if f.get("type") == "external"
+                    else f.get("name")
+                )
                 for f in prop_data.get("files", [])
-            ]
+            ],
         }
 
         handler = handlers.get(prop_type)

notionary/core/page/relations/notion_page_relation_manager.py

@@ -1,17 +1,24 @@
 from typing import Any, Dict, List, Optional
 from notionary.core.notion_client import NotionClient
-from notionary.core.page.relations.notion_page_title_resolver import NotionPageTitleResolver
-from notionary.core.page.relations.relation_operation_result import RelationOperationResult
+from notionary.core.page.relations.notion_page_title_resolver import (
+    NotionPageTitleResolver,
+)
+from notionary.core.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):
     """
     Manager for relation properties of a Notion page.
     Manages links between pages and loads available relation options.
     """
 
-    def __init__(self, page_id: str, client: NotionClient, database_id: Optional[str] = None):
+    def __init__(
+        self, page_id: str, client: NotionClient, database_id: Optional[str] = None
+    ):
         """
         Initializes the relation manager.
 
@@ -75,7 +82,8 @@ class NotionRelationManager(LoggingMixin):
         properties = await self._get_page_properties()
 
         return [
-            prop_name for prop_name, prop_data in properties.items()
+            prop_name
+            for prop_name, prop_data in properties.items()
             if prop_data.get("type") == "relation"
         ]
 
@@ -101,7 +109,9 @@ class NotionRelationManager(LoggingMixin):
 
         return [rel.get("id") for rel in prop_data["relation"]]
 
-    async def get_relation_details(self, property_name: str) -> Optional[Dict[str, Any]]:
+    async def get_relation_details(
+        self, property_name: str
+    ) -> Optional[Dict[str, Any]]:
         """
         Returns details about the relation property, including the linked database.
 
@@ -153,7 +163,9 @@ class NotionRelationManager(LoggingMixin):
 
         return relation_details.get("database_id")
 
-    async def get_relation_options(self, property_name: str, limit: int = 100) -> List[Dict[str, Any]]:
+    async def get_relation_options(
+        self, property_name: str, limit: int = 100
+    ) -> List[Dict[str, Any]]:
         """
         Returns available options for a relation property.
 
@@ -174,7 +186,7 @@ class NotionRelationManager(LoggingMixin):
                 f"databases/{related_db_id}/query",
                 {
                     "page_size": limit,
-                }
+                },
             )
 
             if not query_result or "results" not in query_result:
@@ -186,10 +198,7 @@ class NotionRelationManager(LoggingMixin):
                 title = self._extract_title_from_page(page)
 
                 if page_id and title:
-                    options.append({
-                        "id": page_id,
-                        "name": title
-                    })
+                    options.append({"id": page_id, "name": title})
 
             return options
         except Exception as e:
@@ -214,11 +223,15 @@ class NotionRelationManager(LoggingMixin):
         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 "".join(
+                    [text_obj.get("plain_text", "") for text_obj in title_parts]
+                )
 
         return None
 
-    async def add_relation(self, property_name: str, page_ids: List[str]) -> Optional[Dict[str, Any]]:
+    async def add_relation(
+        self, property_name: str, page_ids: List[str]
+    ) -> Optional[Dict[str, Any]]:
         """
         Adds one or more relations.
 
@@ -233,18 +246,12 @@ class NotionRelationManager(LoggingMixin):
 
         all_relations = list(set(existing_relations + page_ids))
 
-        relation_payload = {
-            "relation": [{"id": page_id} for page_id in all_relations]
-        }
+        relation_payload = {"relation": [{"id": page_id} for page_id in all_relations]}
 
         try:
             result = await self._client.patch(
                 f"pages/{self._page_id}",
-                {
-                    "properties": {
-                        property_name: relation_payload
-                    }
-                },
+                {"properties": {property_name: relation_payload}},
             )
 
             self._page_properties = None
@@ -254,7 +261,9 @@ class NotionRelationManager(LoggingMixin):
             self.logger.error("Error adding relation: %s", str(e))
             return None
 
-    async def add_relation_by_name(self, property_name: str, page_titles: List[str]) -> RelationOperationResult:
+    async def add_relation_by_name(
+        self, property_name: str, page_titles: List[str]
+    ) -> RelationOperationResult:
         """
         Adds one or more relations based on page titles.
 
@@ -268,9 +277,13 @@ class NotionRelationManager(LoggingMixin):
         found_pages = []
         not_found_pages = []
         page_ids = []
-        
-        self.logger.info("Attempting to add %d relation(s) to property '%s'", len(page_titles), property_name)
-        
+
+        self.logger.info(
+            "Attempting to add %d relation(s) to property '%s'",
+            len(page_titles),
+            property_name,
+        )
+
         for page in page_titles:
             if is_valid_uuid(page):
                 page_ids.append(page)
@@ -287,38 +300,51 @@ class NotionRelationManager(LoggingMixin):
                     self.logger.warning("No page found with title '%s'", page)
 
         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)
+            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
+            )
 
         api_response = await self.add_relation(property_name, page_ids)
-        
+
         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
+                api_response=api_response,
             )
-            
+
             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)
+                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)
-                
+                self.logger.info(
+                    "Successfully added all %d relation(s) to '%s'",
+                    len(page_ids),
+                    property_name,
+                )
+
             return result
-        
+
         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
+            page_ids_added=page_ids,
         )
 
-    async def set_relations(self, property_name: str, page_ids: List[str]) -> Optional[Dict[str, Any]]:
+    async def set_relations(
+        self, property_name: str, page_ids: List[str]
+    ) -> Optional[Dict[str, Any]]:
         """
         Sets the relations to the specified IDs (replaces existing ones).
 
@@ -329,18 +355,12 @@ class NotionRelationManager(LoggingMixin):
         Returns:
             Optional[Dict[str, Any]]: API response or None on error
         """
-        relation_payload = {
-            "relation": [{"id": page_id} for page_id in page_ids]
-        }
+        relation_payload = {"relation": [{"id": page_id} for page_id in page_ids]}
 
         try:
             result = await self._client.patch(
                 f"pages/{self._page_id}",
-                {
-                    "properties": {
-                        property_name: relation_payload
-                    }
-                },
+                {"properties": {property_name: relation_payload}},
             )
 
             self._page_properties = None
@@ -349,16 +369,15 @@ class NotionRelationManager(LoggingMixin):
         except Exception as e:
             self.logger.error("Error setting relations: %s", str(e))
             return None
-        
+
     async def get_all_relations(self) -> Dict[str, List[str]]:
-        """ Returns all relation properties and their values.
-        """
+        """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
+
+        return result

notionary/core/page/relations/notion_page_title_resolver.py

@@ -6,7 +6,7 @@ from notionary.util.logging_mixin import LoggingMixin
 class NotionPageTitleResolver(LoggingMixin):
     def __init__(self, client: NotionClient):
         self._client = client
-        
+
     async def get_page_id_by_title(self, title: str) -> Optional[str]:
         """
         Searches for a Notion page by its title and returns the corresponding page ID if found.
@@ -14,13 +14,7 @@ class NotionPageTitleResolver(LoggingMixin):
         try:
             search_results = await self._client.post(
                 "search",
-                {
-                    "query": title,
-                    "filter": {
-                        "value": "page",
-                        "property": "object"
-                    }
-                }
+                {"query": title, "filter": {"value": "page", "property": "object"}},
             )
 
             for result in search_results.get("results", []):
@@ -30,14 +24,20 @@ class NotionPageTitleResolver(LoggingMixin):
                     if prop_value.get("type") == "title":
                         title_texts = prop_value.get("title", [])
 
-                        page_title = " ".join([t.get("plain_text", "") for t in title_texts])
+                        page_title = " ".join(
+                            [t.get("plain_text", "") for t in title_texts]
+                        )
 
                         if page_title == title or title in page_title:
-                            self.logger.debug("Found page: '%s' with ID: %s", page_title, result.get("id"))
+                            self.logger.debug(
+                                "Found page: '%s' with ID: %s",
+                                page_title,
+                                result.get("id"),
+                            )
                             return result.get("id")
 
             self.logger.debug("No page found with title '%s'", title)
             return None
         except Exception as e:
             self.logger.error("Error while searching for page '%s': %s", title, e)
-            return None
+            return None

notionary/core/page/relations/page_database_relation.py

@@ -8,11 +8,11 @@ class PageDatabaseRelation(LoggingMixin):
     Manages the relationship between a Notion page and its parent database.
     Provides methods to access database schema and property options.
     """
-    
+
     def __init__(self, page_id: str, client: NotionClient):
         """
         Initialize the page-database relationship handler.
-        
+
         Args:
             page_id: ID of the Notion page
             client: Instance of NotionClient
@@ -22,49 +22,49 @@ class PageDatabaseRelation(LoggingMixin):
         self._parent_database_id = None
         self._database_schema = None
         self._page_data = None
-    
+
     async def _get_page_data(self, force_refresh=False) -> Dict[str, Any]:
         """
         Gets the page data and caches it for future use.
-        
+
         Args:
             force_refresh: Whether to force a refresh of the page data
-            
+
         Returns:
             Dict[str, Any]: The page data
         """
         if self._page_data is None or force_refresh:
             self._page_data = await self._client.get_page(self._page_id)
         return self._page_data
-    
+
     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
         """
         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:
             return None
-            
+
         parent = page_data.get("parent", {})
         if parent.get("type") == "database_id":
             self._parent_database_id = parent.get("database_id")
             return self._parent_database_id
-            
+
         return None
-    
+
     async def is_database_page(self) -> bool:
         """
         Checks if this page belongs to a database.
-        
+
         Returns:
             bool: True if the page belongs to a database, False otherwise
         """
         database_id = await self.get_parent_database_id()
-        return database_id is not None
+        return database_id is not None