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

notionary/{core/page → page}/properites/page_property_manager.py

@@ -1,40 +1,53 @@
 from typing import Dict, Any, List, Optional
-from notionary.core.notion_client import NotionClient
-from notionary.core.page.metadata.metadata_editor import MetadataEditor
-from notionary.core.page.properites.property_operation_result import PropertyOperationResult
-from notionary.core.page.relations.notion_page_title_resolver import NotionPageTitleResolver
-from notionary.core.page.properites.database_property_service import DatabasePropertyService
-from notionary.core.page.relations.page_database_relation import PageDatabaseRelation
-from notionary.core.page.properites.property_value_extractor import PropertyValueExtractor
+from notionary.notion_client import NotionClient
+from notionary.page.metadata.metadata_editor import MetadataEditor
+from notionary.page.properites.property_operation_result import (
+    PropertyOperationResult,
+)
+from notionary.page.relations.notion_page_title_resolver import (
+    NotionPageTitleResolver,
+)
+from notionary.page.properites.database_property_service import (
+    DatabasePropertyService,
+)
+from notionary.page.relations.page_database_relation import PageDatabaseRelation
+from notionary.page.properites.property_value_extractor import (
+    PropertyValueExtractor,
+)
 from notionary.util.logging_mixin import LoggingMixin
 
+
 class PagePropertyManager(LoggingMixin):
     """Verwaltet den Zugriff auf und die Änderung von Seiteneigenschaften."""
-    
-    def __init__(self, page_id: str, client: NotionClient, 
-                metadata_editor: MetadataEditor, 
-                db_relation: PageDatabaseRelation):
+
+    def __init__(
+        self,
+        page_id: str,
+        client: NotionClient,
+        metadata_editor: MetadataEditor,
+        db_relation: PageDatabaseRelation,
+    ):
         self._page_id = page_id
         self._client = client
         self._page_data = None
         self._metadata_editor = metadata_editor
         self._db_relation = db_relation
         self._db_property_service = None
-        
+
         self._extractor = PropertyValueExtractor(self.logger)
         self._title_resolver = NotionPageTitleResolver(client)
-    
+
     async def get_properties(self) -> Dict[str, Any]:
         """Retrieves all properties of the page."""
         page_data = await self._get_page_data()
         if page_data and "properties" in page_data:
             return page_data["properties"]
         return {}
-    
+
     async def get_property_value(self, property_name: str, relation_getter=None) -> Any:
         """
         Get the value of a specific property.
-        
+
         Args:
             property_name: Name of the property to get
             relation_getter: Optional callback function to get relation values
@@ -42,105 +55,121 @@ class PagePropertyManager(LoggingMixin):
         properties = await self.get_properties()
         if property_name not in properties:
             return None
-            
+
         prop_data = properties[property_name]
         return await self._extractor.extract(property_name, prop_data, relation_getter)
-    
 
-    async def set_property_by_name(self, property_name: str, value: Any) -> PropertyOperationResult:
+    async def set_property_by_name(
+        self, property_name: str, value: Any
+    ) -> PropertyOperationResult:
         """
         Set a property value by name, automatically detecting the property type.
-        
+
         Args:
             property_name: Name of the property
             value: Value to set
-            
+
         Returns:
-            PropertyOperationResult: Result of the operation with status, error messages, 
+            PropertyOperationResult: Result of the operation with status, error messages,
                                     and available options if applicable
         """
         property_type = await self.get_property_type(property_name)
-        
+
         if property_type == "relation":
-            result = PropertyOperationResult.from_relation_type_error(property_name, value)
+            result = PropertyOperationResult.from_relation_type_error(
+                property_name, value
+            )
             self.logger.warning(result.error)
             return result
-        
+
         if not await self._db_relation.is_database_page():
-            api_response = await self._metadata_editor.set_property_by_name(property_name, value)
+            api_response = await self._metadata_editor.set_property_by_name(
+                property_name, value
+            )
             if api_response:
                 await self.invalidate_cache()
-                return PropertyOperationResult.from_success(property_name, value, api_response)
+                return PropertyOperationResult.from_success(
+                    property_name, value, api_response
+                )
             return PropertyOperationResult.from_no_api_response(property_name, value)
-        
+
         db_service = await self._init_db_property_service()
-        
+
         if not db_service:
-            api_response = await self._metadata_editor.set_property_by_name(property_name, value)
+            api_response = await self._metadata_editor.set_property_by_name(
+                property_name, value
+            )
             if api_response:
                 await self.invalidate_cache()
-                return PropertyOperationResult.from_success(property_name, value, api_response)
+                return PropertyOperationResult.from_success(
+                    property_name, value, api_response
+                )
             return PropertyOperationResult.from_no_api_response(property_name, value)
-        
-        is_valid, error_message, available_options = await db_service.validate_property_value(
-            property_name, value
+
+        is_valid, error_message, available_options = (
+            await db_service.validate_property_value(property_name, value)
         )
-                
+
         if not is_valid:
             if available_options:
                 options_str = "', '".join(available_options)
                 detailed_error = f"{error_message}\nAvailable options for '{property_name}': '{options_str}'"
                 self.logger.warning(detailed_error)
             else:
-                self.logger.warning("%s\nNo valid options available for '%s'", error_message, property_name)
-            
+                self.logger.warning(
+                    "%s\nNo valid options available for '%s'",
+                    error_message,
+                    property_name,
+                )
+
             return PropertyOperationResult.from_error(
-                property_name, 
-                error_message,
-                value,
-                available_options
+                property_name, error_message, value, available_options
             )
-            
-        api_response = await self._metadata_editor.set_property_by_name(property_name, value)
+
+        api_response = await self._metadata_editor.set_property_by_name(
+            property_name, value
+        )
         if api_response:
             await self.invalidate_cache()
-            return PropertyOperationResult.from_success(property_name, value, api_response)
-        
+            return PropertyOperationResult.from_success(
+                property_name, value, api_response
+            )
+
         return PropertyOperationResult.from_no_api_response(property_name, value)
-        
+
     async def get_property_type(self, property_name: str) -> Optional[str]:
         """Gets the type of a specific property."""
         db_service = await self._init_db_property_service()
         if db_service:
             return await db_service.get_property_type(property_name)
         return None
-    
+
     async def get_available_options_for_property(self, property_name: str) -> List[str]:
         """Gets the available option names for a property."""
         db_service = await self._init_db_property_service()
         if db_service:
             return await db_service.get_option_names(property_name)
         return []
-    
+
     async def _get_page_data(self, force_refresh=False) -> Dict[str, Any]:
         """Gets the page data and caches it for future use."""
         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 invalidate_cache(self) -> None:
         """Forces a refresh of the cached page data on next access."""
         self._page_data = None
-        
+
     async def _init_db_property_service(self) -> Optional[DatabasePropertyService]:
         """Lazily initializes the database property service if needed."""
         if self._db_property_service is not None:
             return self._db_property_service
-            
+
         database_id = await self._db_relation.get_parent_database_id()
         if not database_id:
             return None
-        
+
         self._db_property_service = DatabasePropertyService(database_id, self._client)
         await self._db_property_service.load_schema()
-        return self._db_property_service
+        return self._db_property_service

notionary/{core/page → page}/properites/property_formatter.py

@@ -93,4 +93,4 @@ class NotionPropertyFormatter(LoggingMixin):
                 self.logger.warning("Unknown property type: %s", property_type)
             return None
 
-        return formatter(value)
+        return formatter(value)

notionary/{core/page → 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 → 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)