notionary 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

notionary/{core/page → 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.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):
     """
     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 → page}/relations/notion_page_title_resolver.py

@@ -1,12 +1,12 @@
 from typing import Optional
-from notionary.core.notion_client import NotionClient
+from notionary.notion_client import NotionClient
 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 → page}/relations/page_database_relation.py

@@ -1,5 +1,5 @@
 from typing import Dict, Optional, Any
-from notionary.core.notion_client import NotionClient
+from notionary.notion_client import NotionClient
 from notionary.util.logging_mixin import LoggingMixin
 
 
@@ -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

notionary/{core/page → page}/relations/relation_operation_result.py

@@ -1,11 +1,12 @@
 from typing import Any, Dict, List, Optional
 from dataclasses import dataclass, field
 
+
 @dataclass
 class RelationOperationResult:
     """
     Result of a relation operation in Notion.
-    
+
     Attributes:
         success: Whether the operation was successful overall
         property_name: Name of the affected relation property
@@ -15,6 +16,7 @@ class RelationOperationResult:
         error: Error message, if any
         api_response: The original API response
     """
+
     success: bool
     property_name: str
     found_pages: List[str] = field(default_factory=list)
@@ -22,32 +24,38 @@ class RelationOperationResult:
     page_ids_added: List[str] = field(default_factory=list)
     error: Optional[str] = None
     api_response: Optional[Dict[str, Any]] = None
-    
+
     NO_API_RESPONSE = "Failed to update relation (no API response)"
     NO_PAGES_FOUND = "No valid pages found for relation"
-    
+
     @classmethod
-    def from_success(cls, property_name: str, 
-                     found_pages: List[str], 
-                     page_ids_added: List[str], 
-                     api_response: Dict[str, Any],
-                     not_found_pages: Optional[List[str]] = None) -> "RelationOperationResult":
+    def from_success(
+        cls,
+        property_name: str,
+        found_pages: List[str],
+        page_ids_added: List[str],
+        api_response: Dict[str, Any],
+        not_found_pages: Optional[List[str]] = None,
+    ) -> "RelationOperationResult":
         """Creates a success result."""
         return cls(
-            success=True, 
+            success=True,
             property_name=property_name,
             found_pages=found_pages,
             not_found_pages=not_found_pages or [],
             page_ids_added=page_ids_added,
-            api_response=api_response
+            api_response=api_response,
         )
-    
+
     @classmethod
-    def from_error(cls, property_name: str, 
-                  error: str,
-                  found_pages: Optional[List[str]] = None,
-                  not_found_pages: Optional[List[str]] = None,
-                  page_ids_added: Optional[List[str]] = None) -> "RelationOperationResult":
+    def from_error(
+        cls,
+        property_name: str,
+        error: str,
+        found_pages: Optional[List[str]] = None,
+        not_found_pages: Optional[List[str]] = None,
+        page_ids_added: Optional[List[str]] = None,
+    ) -> "RelationOperationResult":
         """Creates an error result."""
         return cls(
             success=False,
@@ -55,81 +63,82 @@ class RelationOperationResult:
             found_pages=found_pages or [],
             not_found_pages=not_found_pages or [],
             page_ids_added=page_ids_added or [],
-            error=error
+            error=error,
         )
-    
+
     @classmethod
-    def from_no_pages_found(cls, property_name: str, 
-                            not_found_pages: List[str]) -> "RelationOperationResult":
+    def from_no_pages_found(
+        cls, property_name: str, not_found_pages: List[str]
+    ) -> "RelationOperationResult":
         """Creates a standardized result for when no pages were found."""
         return cls.from_error(
             property_name=property_name,
             error=cls.NO_PAGES_FOUND,
-            not_found_pages=not_found_pages
+            not_found_pages=not_found_pages,
         )
 
     @classmethod
-    def from_no_api_response(cls, property_name: str, 
-                            found_pages: List[str],
-                            page_ids_added: List[str]) -> "RelationOperationResult":
+    def from_no_api_response(
+        cls, property_name: str, found_pages: List[str], page_ids_added: List[str]
+    ) -> "RelationOperationResult":
         """Creates a standardized result for a missing API response."""
         return cls.from_error(
             property_name=property_name,
             error=cls.NO_API_RESPONSE,
             found_pages=found_pages,
-            page_ids_added=page_ids_added
+            page_ids_added=page_ids_added,
         )
-    
+
     @property
     def has_not_found_pages(self) -> bool:
         """Returns True if there were any pages that couldn't be found."""
         return len(self.not_found_pages) > 0
-    
+
     @property
     def has_found_pages(self) -> bool:
         """Returns True if any pages were found."""
         return len(self.found_pages) > 0
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """Converts the result to a dictionary."""
         result = {
             "success": self.success,
             "property": self.property_name,
         }
-        
+
         if self.found_pages:
             result["found_pages"] = self.found_pages
-            
+
         if self.not_found_pages:
             result["not_found_pages"] = self.not_found_pages
-            
+
         if self.page_ids_added:
             result["page_ids_added"] = self.page_ids_added
-        
+
         if not self.success:
             result["error"] = self.error
-            
+
         if self.api_response:
             result["api_response"] = self.api_response
-            
+
         return result
-    
+
     def __str__(self) -> str:
         """String representation of the result."""
         if self.success:
             base = f"Success: Added {len(self.page_ids_added)} relation(s) to property '{self.property_name}'"
-            
+
             if self.not_found_pages:
                 pages_str = "', '".join(self.not_found_pages)
                 base += f"\nWarning: Could not find pages: '{pages_str}'"
-                
+
             return base
-        
+
         if not self.found_pages and self.not_found_pages:
             pages_str = "', '".join(self.not_found_pages)
             return f"Error: {self.error}\nNone of the requested pages were found: '{pages_str}'"
-        
+
         if self.found_pages and not self.page_ids_added:
             return f"Error: {self.error}\nPages were found but could not be added to the relation."
-            
-        return f"Error: {self.error}"
+
+        return f"Error: {self.error}"

notionary/util/page_id_utils.py

@@ -4,39 +4,45 @@ from typing import Optional
 UUID_PATTERN = r"^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$"
 UUID_RAW_PATTERN = r"([a-f0-9]{32})"
 
+
 def extract_uuid(source: str) -> Optional[str]:
     if is_valid_uuid(source):
         return source
-        
+
     match = re.search(UUID_RAW_PATTERN, source.lower())
     if not match:
         return None
-    
+
     uuid_raw = match.group(1)
     return f"{uuid_raw[0:8]}-{uuid_raw[8:12]}-{uuid_raw[12:16]}-{uuid_raw[16:20]}-{uuid_raw[20:32]}"
 
+
 def is_valid_uuid(uuid: str) -> bool:
     return bool(re.match(UUID_PATTERN, uuid.lower()))
 
+
 def format_uuid(value: str) -> Optional[str]:
     if is_valid_uuid(value):
         return value
     return extract_uuid(value)
 
-def extract_and_validate_page_id(page_id: Optional[str], url: Optional[str]) -> str:
+
+def extract_and_validate_page_id(
+    page_id: Optional[str] = None, url: Optional[str] = None
+) -> str:
     if not page_id and not url:
         raise ValueError("Either page_id or url must be provided")
-    
+
     candidate = page_id or url
-    
+
     if is_valid_uuid(candidate):
         return candidate
-        
+
     extracted_id = extract_uuid(candidate)
     if not extracted_id:
         raise ValueError(f"Could not extract a valid UUID from: {candidate}")
-    
+
     formatted = format_uuid(extracted_id)
     if not formatted or not is_valid_uuid(formatted):
         raise ValueError(f"Invalid UUID format: {formatted}")
-    return formatted
+    return formatted

{notionary-0.1.11.dist-info → notionary-0.1.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionary
-Version: 0.1.11
+Version: 0.1.13
 Summary: A toolkit to convert between Markdown and Notion blocks
 Home-page: https://github.com/mathisarends/notionary
 Author: Mathis Arends