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

notionary/{core/page → page}/metadata/metadata_editor.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, Optional
-from notionary.core.notion_client import NotionClient
-from notionary.core.page.properites.property_formatter import NotionPropertyFormatter
+from notionary.notion_client import NotionClient
+from notionary.page.properites.property_formatter import NotionPropertyFormatter
 from notionary.util.logging_mixin import LoggingMixin
 
 
@@ -20,90 +20,103 @@ class MetadataEditor(LoggingMixin):
             },
         )
 
-    async def set_property(self, property_name: str, property_value: Any, property_type: str) -> Optional[Dict[str, Any]]:
-            """
-            Generic method to set any property on a Notion page.
-            
-            Args:
-                property_name: The name of the property in Notion
-                property_value: The value to set
-                property_type: The type of property ('select', 'multi_select', 'status', 'relation', etc.)
-                
-            Returns:
-                Optional[Dict[str, Any]]: The API response or None if the operation fails
-            """
-            property_payload = self._property_formatter.format_value(property_type, property_value)
-            
-            if not property_payload:
-                self.logger.warning("Could not create payload for property type: %s", property_type)
-                return None
-                
-            return await self._client.patch(
-                f"pages/{self.page_id}",
-                {
-                    "properties": {
-                        property_name: property_payload
-                    }
-                },
+    async def set_property(
+        self, property_name: str, property_value: Any, property_type: str
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Generic method to set any property on a Notion page.
+
+        Args:
+            property_name: The name of the property in Notion
+            property_value: The value to set
+            property_type: The type of property ('select', 'multi_select', 'status', 'relation', etc.)
+
+        Returns:
+            Optional[Dict[str, Any]]: The API response or None if the operation fails
+        """
+        property_payload = self._property_formatter.format_value(
+            property_type, property_value
+        )
+
+        if not property_payload:
+            self.logger.warning(
+                "Could not create payload for property type: %s", property_type
             )
+            return None
 
+        return await self._client.patch(
+            f"pages/{self.page_id}",
+            {"properties": {property_name: property_payload}},
+        )
 
     async def get_property_schema(self) -> Dict[str, Dict[str, Any]]:
         """
         Retrieves the schema for all properties of the page.
-        
+
         Returns:
             Dict[str, Dict[str, Any]]: A dictionary mapping property names to their schema
         """
         page_data = await self._client.get_page(self.page_id)
         property_schema = {}
-        
+
         if not page_data or "properties" not in page_data:
             return property_schema
-            
+
         for prop_name, prop_data in page_data["properties"].items():
             prop_type = prop_data.get("type")
             property_schema[prop_name] = {
                 "id": prop_data.get("id"),
                 "type": prop_type,
-                "name": prop_name
+                "name": prop_name,
             }
-            
+
             try:
                 if prop_type == "select" and "select" in prop_data:
                     # Make sure prop_data["select"] is a dictionary before calling .get()
                     if isinstance(prop_data["select"], dict):
-                        property_schema[prop_name]["options"] = prop_data["select"].get("options", [])
+                        property_schema[prop_name]["options"] = prop_data["select"].get(
+                            "options", []
+                        )
                 elif prop_type == "multi_select" and "multi_select" in prop_data:
                     # Make sure prop_data["multi_select"] is a dictionary before calling .get()
                     if isinstance(prop_data["multi_select"], dict):
-                        property_schema[prop_name]["options"] = prop_data["multi_select"].get("options", [])
+                        property_schema[prop_name]["options"] = prop_data[
+                            "multi_select"
+                        ].get("options", [])
                 elif prop_type == "status" and "status" in prop_data:
                     # Make sure prop_data["status"] is a dictionary before calling .get()
                     if isinstance(prop_data["status"], dict):
-                        property_schema[prop_name]["options"] = prop_data["status"].get("options", [])
+                        property_schema[prop_name]["options"] = prop_data["status"].get(
+                            "options", []
+                        )
             except Exception as e:
-                if hasattr(self, 'logger') and self.logger:
-                    self.logger.warning("Error processing property schema for '%s': %s", prop_name, e)
-                
+                if hasattr(self, "logger") and self.logger:
+                    self.logger.warning(
+                        "Error processing property schema for '%s': %s", prop_name, e
+                    )
+
         return property_schema
-        
-    async def set_property_by_name(self, property_name: str, value: Any) -> Optional[Dict[str, Any]]:
+
+    async def set_property_by_name(
+        self, property_name: str, value: Any
+    ) -> Optional[Dict[str, Any]]:
         """
         Sets a property value based on the property name, automatically detecting the property type.
-        
+
         Args:
             property_name: The name of the property in Notion
             value: The value to set
-            
+
         Returns:
             Optional[Dict[str, Any]]: The API response or None if the operation fails
         """
         property_schema = await self.get_property_schema()
-        
+
         if property_name not in property_schema:
-            self.logger.warning("Property '%s' not found in database schema", property_name)
+            self.logger.warning(
+                "Property '%s' not found in database schema", property_name
+            )
             return None
-            
+
         property_type = property_schema[property_name]["type"]
-        return await self.set_property(property_name, value, property_type)
+        return await self.set_property(property_name, value, property_type)

notionary/{core/page → page}/metadata/notion_icon_manager.py

@@ -1,13 +1,14 @@
 from typing import Any, Dict, Optional
 
-from notionary.core.notion_client import NotionClient
+from notionary.notion_client import NotionClient
 from notionary.util.logging_mixin import LoggingMixin
 
+
 class NotionPageIconManager(LoggingMixin):
     def __init__(self, page_id: str, client: NotionClient):
         self.page_id = page_id
         self._client = client
-        
+
     async def set_icon(
         self, emoji: Optional[str] = None, external_url: Optional[str] = None
     ) -> Optional[Dict[str, Any]]:
@@ -19,28 +20,25 @@ class NotionPageIconManager(LoggingMixin):
             return None
 
         return await self._client.patch(f"pages/{self.page_id}", {"icon": icon})
-    
-    
+
     async def get_icon(self) -> Optional[str]:
         """
         Retrieves the page icon - either emoji or external URL.
-        
+
         Returns:
             str: Emoji character or URL if set, None if no icon
         """
         page_data = await self._client.get_page(self.page_id)
-        
+
         if not page_data or "icon" not in page_data:
             return None
-        
+
         icon_data = page_data.get("icon", {})
         icon_type = icon_data.get("type")
-        
+
         if icon_type == "emoji":
             return icon_data.get("emoji")
         elif icon_type == "external":
             return icon_data.get("external", {}).get("url")
-        
-        return None  
-    
-    
+
+        return None

notionary/{core/page → page}/metadata/notion_page_cover_manager.py

@@ -1,48 +1,43 @@
-
 import random
 from typing import Any, Dict, Optional
-from notionary.core.notion_client import NotionClient
+from notionary.notion_client import NotionClient
 from notionary.util.logging_mixin import LoggingMixin
 
+
 class NotionPageCoverManager(LoggingMixin):
     def __init__(self, page_id: str, client: NotionClient):
         self.page_id = page_id
         self._client = client
-        
+
     async def set_cover(self, external_url: str) -> Optional[Dict[str, Any]]:
-        """Sets a cover image from an external URL.
-        """
-        
+        """Sets a cover image from an external URL."""
+
         return await self._client.patch(
             f"pages/{self.page_id}",
             {"cover": {"type": "external", "external": {"url": external_url}}},
         )
-        
+
     async def set_random_gradient_cover(self) -> Optional[Dict[str, Any]]:
-        """ Sets a random gradient cover from Notion's default gradient covers.
-        """
+        """Sets a random gradient cover from Notion's default gradient covers."""
         default_notion_covers = [
-            "https://www.notion.so/images/page-cover/gradients_8.png", 
+            "https://www.notion.so/images/page-cover/gradients_8.png",
             "https://www.notion.so/images/page-cover/gradients_2.png",
             "https://www.notion.so/images/page-cover/gradients_11.jpg",
             "https://www.notion.so/images/page-cover/gradients_10.jpg",
             "https://www.notion.so/images/page-cover/gradients_5.png",
-            "https://www.notion.so/images/page-cover/gradients_3.png"
+            "https://www.notion.so/images/page-cover/gradients_3.png",
         ]
-        
+
         random_cover_url = random.choice(default_notion_covers)
-        
+
         return await self.set_cover(random_cover_url)
-    
-    
+
     async def get_cover_url(self) -> str:
-        """Retrieves the current cover image URL of the page.
-        """
-        
+        """Retrieves the current cover image URL of the page."""
+
         page_data = await self._client.get_page(self.page_id)
-        
+
         if not page_data:
             return ""
-        
+
         return page_data.get("cover", {}).get("external", {}).get("url", "")
-