notionary 0.1.6__py3-none-any.whl → 0.1.7__py3-none-any.whl

notionary/core/page/properites/page_property_manager.py

@@ -0,0 +1,146 @@
+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.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):
+        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
+        """
+        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:
+        """
+        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, 
+                                    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)
+            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)
+            if api_response:
+                await self.invalidate_cache()
+                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)
+            if api_response:
+                await self.invalidate_cache()
+                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
+        )
+                
+        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)
+            
+            return PropertyOperationResult.from_error(
+                property_name, 
+                error_message,
+                value,
+                available_options
+            )
+            
+        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_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

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

@@ -4,10 +4,9 @@ from notionary.util.logging_mixin import LoggingMixin
 
 
 class NotionPropertyFormatter(LoggingMixin):
-    """Klasse zur Formatierung von Notion-Eigenschaften nach Typ."""
+    """Class for formatting Notion properties based on their type."""
 
     def __init__(self):
-        # Mapping von Typen zu Formatierungsmethoden
         self._formatters = {
             "title": self.format_title,
             "rich_text": self.format_rich_text,
@@ -24,74 +23,74 @@ class NotionPropertyFormatter(LoggingMixin):
         }
 
     def format_title(self, value: Any) -> Dict[str, Any]:
-        """Formatiert einen Titel-Wert."""
+        """Formats a title value."""
         return {"title": [{"type": "text", "text": {"content": str(value)}}]}
 
     def format_rich_text(self, value: Any) -> Dict[str, Any]:
-        """Formatiert einen Rich-Text-Wert."""
+        """Formats a rich text value."""
         return {"rich_text": [{"type": "text", "text": {"content": str(value)}}]}
 
     def format_url(self, value: str) -> Dict[str, Any]:
-        """Formatiert eine URL."""
+        """Formats a URL value."""
         return {"url": value}
 
     def format_email(self, value: str) -> Dict[str, Any]:
-        """Formatiert eine E-Mail-Adresse."""
+        """Formats an email address."""
         return {"email": value}
 
     def format_phone_number(self, value: str) -> Dict[str, Any]:
-        """Formatiert eine Telefonnummer."""
+        """Formats a phone number."""
         return {"phone_number": value}
 
     def format_number(self, value: Any) -> Dict[str, Any]:
-        """Formatiert eine Zahl."""
+        """Formats a numeric value."""
         return {"number": float(value)}
 
     def format_checkbox(self, value: Any) -> Dict[str, Any]:
-        """Formatiert einen Checkbox-Wert."""
+        """Formats a checkbox value."""
         return {"checkbox": bool(value)}
 
     def format_select(self, value: str) -> Dict[str, Any]:
-        """Formatiert einen Select-Wert."""
+        """Formats a select value."""
         return {"select": {"name": str(value)}}
 
     def format_multi_select(self, value: Any) -> Dict[str, Any]:
-        """Formatiert einen Multi-Select-Wert."""
+        """Formats a multi-select value."""
         if isinstance(value, list):
             return {"multi_select": [{"name": item} for item in value]}
         return {"multi_select": [{"name": str(value)}]}
 
     def format_date(self, value: Any) -> Dict[str, Any]:
-        """Formatiert ein Datum."""
+        """Formats a date value."""
         if isinstance(value, dict) and "start" in value:
             return {"date": value}
         return {"date": {"start": str(value)}}
 
     def format_status(self, value: str) -> Dict[str, Any]:
-        """Formatiert einen Status-Wert."""
+        """Formats a status value."""
         return {"status": {"name": str(value)}}
 
     def format_relation(self, value: Any) -> Dict[str, Any]:
-        """Formatiert einen Relations-Wert."""
+        """Formats a relation value."""
         if isinstance(value, list):
             return {"relation": [{"id": item} for item in value]}
         return {"relation": [{"id": str(value)}]}
 
     def format_value(self, property_type: str, value: Any) -> Optional[Dict[str, Any]]:
         """
-        Formatiert einen Wert entsprechend des angegebenen Eigenschaftstyps.
+        Formats a value according to the given Notion property type.
 
         Args:
-            property_type: Notion-Eigenschaftstyp (z.B. "title", "rich_text", "status")
-            value: Der zu formatierende Wert
+            property_type: Notion property type (e.g., "title", "rich_text", "status")
+            value: The value to be formatted
 
         Returns:
-            Formatierter Wert als Dictionary oder None bei unbekanntem Typ
+            A dictionary with the formatted value, or None if the type is unknown.
         """
         formatter = self._formatters.get(property_type)
         if not formatter:
             if self.logger:
-                self.logger.warning("Unbekannter Eigenschaftstyp: %s", property_type)
+                self.logger.warning("Unknown property type: %s", property_type)
             return None
 
-        return formatter(value)
+        return formatter(value)

notionary/core/page/properites/property_operation_result.py

@@ -0,0 +1,103 @@
+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
+        value: The value that was set or retrieved
+        error: Error message, if any
+        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":
+        """Creates a success result."""
+        return cls(
+            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":
+        """Creates an error result."""
+        return cls(
+            success=False,
+            property_name=property_name,
+            value=value,
+            error=error,
+            available_options=available_options or []
+        )
+    
+    @classmethod
+    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
+        )
+        
+    @classmethod
+    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":
+        """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}"

notionary/core/page/properites/property_value_extractor.py

@@ -0,0 +1,46 @@
+import asyncio
+from typing import Any, Awaitable, Callable
+
+
+class PropertyValueExtractor:
+    def __init__(self, logger=None):
+        self.logger = logger
+
+    async def extract(
+        self,
+        property_name: str,
+        prop_data: dict,
+        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", [])),
+            "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,
+            "date": lambda: prop_data.get("date"),
+            "checkbox": lambda: prop_data.get("checkbox"),
+            "url": lambda: prop_data.get("url"),
+            "email": lambda: prop_data.get("email"),
+            "phone_number": lambda: prop_data.get("phone_number"),
+            "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")
+                for f in prop_data.get("files", [])
+            ]
+        }
+
+        handler = handlers.get(prop_type)
+        if handler is None:
+            if self.logger:
+                self.logger.warning(f"Unsupported property type: {prop_type}")
+            return None
+
+        result = handler()
+        return await result if asyncio.iscoroutine(result) else result