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

notionary/core/page/notion_page_manager.py

@@ -1,4 +1,5 @@
-from typing import Any, Dict, List, Optional
+import asyncio
+from typing import Any, Dict, List, Optional, Union
 from notionary.core.converters.registry.block_element_registry import (
     BlockElementRegistry,
 )
@@ -6,15 +7,20 @@ from notionary.core.converters.registry.block_element_registry_builder import (
     BlockElementRegistryBuilder,
 )
 from notionary.core.notion_client import NotionClient
-from notionary.core.page.page_content_manager import PageContentManager
+from notionary.core.page.metadata.metadata_editor import MetadataEditor
+from notionary.core.page.metadata.notion_icon_manager import NotionPageIconManager
+from notionary.core.page.metadata.notion_page_cover_manager import NotionPageCoverManager
+from notionary.core.page.properites.database_property_service import DatabasePropertyService
+from notionary.core.page.relations.notion_page_relation_manager import NotionRelationManager
+from notionary.core.page.content.page_content_manager import PageContentManager
+from notionary.core.page.properites.page_property_manager import PagePropertyManager
 from notionary.util.logging_mixin import LoggingMixin
-from notionary.core.page.meta_data.metadata_editor import MetadataEditor
-from notionary.util.uuid_utils import extract_uuid, format_uuid, is_valid_uuid
-
+from notionary.util.page_id_utils import extract_and_validate_page_id
+from notionary.core.page.relations.page_database_relation import PageDatabaseRelation
 
 class NotionPageManager(LoggingMixin):
     """
-    High-Level Fassade zur Verwaltung von Inhalten und Metadaten einer Notion-Seite.
+    High-Level Facade for managing content and metadata of a Notion page.
     """
 
     def __init__(
@@ -24,38 +30,60 @@ class NotionPageManager(LoggingMixin):
         url: Optional[str] = None,
         token: Optional[str] = None,
     ):
-        if not page_id and not url:
-            raise ValueError("Either page_id or url must be provided")
-
-        if not page_id and url:
-            page_id = extract_uuid(url)
-            if not page_id:
-                raise ValueError(f"Could not extract a valid UUID from the URL: {url}")
-
-        page_id = format_uuid(page_id)
-        if not page_id or not is_valid_uuid(page_id):
-            raise ValueError(f"Invalid UUID format: {page_id}")
+        self._page_id = extract_and_validate_page_id(page_id=page_id, url=url)
 
-        self._page_id = page_id
         self.url = url
         self._title = title
-
         self._client = NotionClient(token=token)
+        self._page_data = None
 
         self._block_element_registry = (
             BlockElementRegistryBuilder.create_standard_registry()
         )
 
         self._page_content_manager = PageContentManager(
-            page_id=page_id,
+            page_id=self._page_id,
             client=self._client,
             block_registry=self._block_element_registry,
         )
-        self._metadata = MetadataEditor(page_id, self._client)
+        self._metadata = MetadataEditor(self._page_id, self._client)
+        self._page_cover_manager = NotionPageCoverManager(page_id=self._page_id, client=self._client)
+        self._page_icon_manager = NotionPageIconManager(page_id=self._page_id, client=self._client)
+        
+        self._db_relation = PageDatabaseRelation(page_id=self._page_id, client=self._client)
+        self._db_property_service = None
+        
+        self._relation_manager = NotionRelationManager(page_id=self._page_id, client=self._client)
+        
+        self._property_manager = PagePropertyManager(
+            self._page_id, 
+            self._client,
+            self._metadata,
+            self._db_relation
+        )
+
+    async def _get_db_property_service(self) -> Optional[DatabasePropertyService]:
+        """
+        Gets the database property service, initializing it if necessary.
+        This is a more intuitive way to work with the instance variable.
+        
+        Returns:
+            Optional[DatabasePropertyService]: The database property service or None if not applicable
+        """
+        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
 
     @property
     def page_id(self) -> Optional[str]:
-        """Get the title of the page."""
+        """Get the ID of the page."""
         return self._page_id
 
     @property
@@ -69,9 +97,7 @@ class NotionPageManager(LoggingMixin):
     @block_registry.setter
     def block_registry(self, block_registry: BlockElementRegistry) -> None:
         """Set the block element registry for the page content manager."""
-
         self._block_element_registry = block_registry
-
         self._page_content_manager = PageContentManager(
             page_id=self._page_id, client=self._client, block_registry=block_registry
         )
@@ -86,66 +112,199 @@ class NotionPageManager(LoggingMixin):
         await self._page_content_manager.clear()
         return await self._page_content_manager.append_markdown(markdown)
 
-    async def get_blocks(self) -> List[Dict[str, Any]]:
-        return await self._page_content_manager.get_blocks()
-
-    async def get_block_children(self, block_id: str) -> List[Dict[str, Any]]:
-        return await self._page_content_manager.get_block_children(block_id)
-
-    async def get_page_blocks_with_children(self) -> List[Dict[str, Any]]:
-        return await self._page_content_manager.get_page_blocks_with_children()
-
     async def get_text(self) -> str:
         return await self._page_content_manager.get_text()
-
+    
     async def set_title(self, title: str) -> Optional[Dict[str, Any]]:
         return await self._metadata.set_title(title)
 
     async def set_page_icon(
         self, emoji: Optional[str] = None, external_url: Optional[str] = None
     ) -> Optional[Dict[str, Any]]:
-        return await self._metadata.set_icon(emoji, external_url)
+        return await self._page_icon_manager.set_icon(emoji, external_url)
     
+    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 get_icon(self) -> Optional[str]:
+        """Retrieves the page icon - either emoji or external URL.
+        """
+        return await self._page_icon_manager.get_icon()
+
     async def get_cover_url(self) -> str:
-        page_data = await self._client.get_page(self._page_id)
-        
-        if not page_data:
-            return ""
-        
-        return page_data.get("cover", {}).get("external", {}).get("url", "")
+        return await self._page_cover_manager.get_cover_url()
 
     async def set_page_cover(self, external_url: str) -> Optional[Dict[str, Any]]:
-        return await self._metadata.set_cover(external_url)
+        return await self._page_cover_manager.set_cover(external_url)
     
     async def set_random_gradient_cover(self) -> Optional[Dict[str, Any]]:
-        return await self._metadata.set_random_gradient_cover()
+        return await self._page_cover_manager.set_random_gradient_cover()
     
     async def get_properties(self) -> Dict[str, Any]:
-        """Retrieves all properties of the page"""
-        page_data = await self._client.get_page(self._page_id)
-        if page_data and "properties" in page_data:
-            return page_data["properties"]
-        return {}
+        """Retrieves all properties of the page."""
+        return await self._property_manager.get_properties()
 
-    async def get_status(self) -> Optional[str]:
+    async def get_property_value(self, property_name: str) -> Any:
+        """Get the value of a specific property."""
+        return await self._property_manager.get_property_value(
+            property_name, 
+            self._relation_manager.get_relation_values
+        )
+    
+    async def set_property_by_name(self, property_name: str, value: Any) -> Optional[Dict[str, Any]]:
+        """ Sets the value of a specific property by its name.
+        """ 
+        return await self._property_manager.set_property_by_name(
+            property_name=property_name, 
+            value=value,
+        )
+        
+    async def is_database_page(self) -> bool:
+        """ Checks if this page belongs to a database.
         """
-        Determines the status of the page (e.g., 'Draft', 'Completed', etc.)
+        return await self._db_relation.is_database_page()
         
-        Returns:
-            Optional[str]: The status as a string or None if not available
+    async def get_parent_database_id(self) -> Optional[str]:
+        """ Gets the ID of the database this page belongs to, if any
+        """
+        return await self._db_relation.get_parent_database_id()
+
+    async def get_available_options_for_property(self, property_name: str) -> List[str]:
+        """ Gets the available option names for a property (select, multi_select, status).
+        """
+        db_service = await self._get_db_property_service()
+        if db_service:
+            return await db_service.get_option_names(property_name)
+        return []
+
+    async def get_property_type(self, property_name: str) -> Optional[str]:
+        """ Gets the type of a specific property.
         """
-        properties = await self.get_properties()
-        if "Status" in properties and properties["Status"].get("status"):
-            return properties["Status"]["status"]["name"]
+        db_service = await self._get_db_property_service()
+        if db_service:
+            return await db_service.get_property_type(property_name)
         return None
+
+    async def get_database_metadata(self, include_types: Optional[List[str]] = None) -> Dict[str, Any]:
+        """ Gets complete metadata about the database this page belongs to.
+        """
+        db_service = await self._get_db_property_service()
+        if db_service:
+            return await db_service.get_database_metadata(include_types)
+        return {"properties": {}}
+
+    async def get_relation_options(self, property_name: str, limit: int = 100) -> List[Dict[str, Any]]:
+            """ Returns available options for a relation property.
+            """
+            return await self._relation_manager.get_relation_options(property_name, limit)
+
+    async def add_relations_by_name(self, relation_property_name: str, page_titles: Union[str, List[str]]) -> Optional[Dict[str, Any]]:
+        """ Adds one or more relations.
+        """
+        return await self._relation_manager.add_relation_by_name(property_name=relation_property_name, page_titles=page_titles)
+
+    async def get_relation_values(self, property_name: str) -> List[str]:
+        """
+        Returns the current relation values for a property.
+        """
+        return await self._relation_manager.get_relation_values(property_name)
+
+    async def get_relation_property_ids(self) -> List[str]:
+        """ Returns a list of all relation property names.
+        """
+        return await self._relation_manager.get_relation_property_ids()
+
+    async def get_all_relations(self) -> Dict[str, List[str]]:
+        """ Returns all relation properties and their values.
+        """
+        return await self._relation_manager.get_all_relations()
+        
+    async def get_status(self) -> Optional[str]:
+        """ Determines the status of the page (e.g., 'Draft', 'Completed', etc.)
+        """
+        return await self.get_property_value("Status")
     
     
-async def main(): 
+    
+async def main():
+    """
+    Demonstriert die Verwendung des refactorierten NotionPageManager.
+    """
+    print("=== NotionPageManager Demo ===")
+    
     page_manager = NotionPageManager(page_id="https://notion.so/1d0389d57bd3805cb34ccaf5804b43ce")
-    cover_url = await page_manager.get_cover_url()
-    print(f"Cover URL: {cover_url}")
     
+    await page_manager.add_relations_by_name("Projekte", ["Fetzen mit Stine"])
+
+
+    input("Drücke Enter, um fortzufahren...")
+
+    
+    is_database_page = await page_manager.is_database_page()
+    
+    if not is_database_page:
+        print("Diese Seite gehört zu keiner Datenbank. Demo wird beendet.")
+        return
+        
+    db_id = await page_manager.get_parent_database_id()
+    print(f"\n2. Datenbank-ID: {db_id}")
+    
+    properties = await page_manager.get_properties()
+    print("\n3. Aktuelle Eigenschaften der Seite:")
+    for prop_name, prop_data in properties.items():
+        prop_type = prop_data.get("type", "unbekannt")
+        
+        value = await page_manager.get_property_value(prop_name)
+        print(f"  - {prop_name} ({prop_type}): {value}")
+    
+    status_options = await page_manager.get_available_options_for_property("Status")
+    print(f"\n4. Verfügbare Status-Optionen: {status_options}")
     
+    tags_options = await page_manager.get_available_options_for_property("Tags")
+    print(f"\n5. Verfügbare Tags-Optionen: {tags_options}")
+    
+    print("\n6. Relation-Eigenschaften und deren Optionen:")
+    for prop_name, prop_data in properties.items():
+        if prop_data.get("type") == "relation":
+            relation_options = await page_manager.get_relation_options(prop_name, limit=5)
+            option_names = [option.get("name", "Unbenannt") for option in relation_options]
+            print(f"  - {prop_name} Relation-Optionen (max. 5): {option_names}")
+    
+    print("\n7. Typen aller Eigenschaften:")
+    for prop_name in properties.keys():
+        prop_type = await page_manager.get_property_type(prop_name)
+        print(f"  - {prop_name}: {prop_type}")
+    
+    if status_options:
+        valid_status = status_options[0]
+        print(f"\n8. Setze Status auf '{valid_status}'...")
+        result = await page_manager.set_property_by_name("Status", valid_status)
+        print(f"   Ergebnis: {'Erfolgreich' if result else 'Fehlgeschlagen'}")
+        
+        current_status = await page_manager.get_status()
+        print(f"   Aktueller Status: {current_status}")
+    
+    # 9. Versuch, einen ungültigen Status zu setzen
+    invalid_status = "Bin King"
+    print(f"\n9. Versuche ungültigen Status '{invalid_status}' zu setzen...")
+    await page_manager.set_property_by_name("Status", invalid_status)
+    
+    # 10. Komplette Datenbank-Metadaten für select-ähnliche Properties abrufen
+    print("\n10. Datenbank-Metadaten für select, multi_select und status Properties:")
+    metadata = await page_manager.get_database_metadata(
+        include_types=["select", "multi_select", "status"]
+    )
+    
+    for prop_name, prop_info in metadata.get("properties", {}).items():
+        option_names = [opt.get("name", "") for opt in prop_info.get("options", [])]
+        print(f"  - {prop_name} ({prop_info.get('type')}): {option_names}")
+    
+    print("\nDemonstration abgeschlossen.")
+
 if __name__ == "__main__":
-    import asyncio
     asyncio.run(main())
+    print("\nDemonstration completed.")

notionary/core/page/properites/database_property_service.py

@@ -0,0 +1,330 @@
+from typing import Dict, List, Optional, Any, Tuple
+from notionary.core.notion_client import NotionClient
+from notionary.util.logging_mixin import LoggingMixin
+
+
+class DatabasePropertyService(LoggingMixin):
+    """
+    Service for working with Notion database properties and options.
+    Provides specialized methods for retrieving property information and validating values.
+    """
+
+    def __init__(self, database_id: str, client: NotionClient):
+        """
+        Initialize the database property service.
+        
+        Args:
+            database_id: ID of the Notion database
+            client: Instance of NotionClient
+        """
+        self._database_id = database_id
+        self._client = client
+        self._schema = None
+    
+    async def load_schema(self, force_refresh=False) -> bool:
+        """
+        Loads the database schema.
+        
+        Args:
+            force_refresh: Whether to force a refresh of the schema
+            
+        Returns:
+            bool: True if schema loaded successfully, False otherwise
+        """
+        if self._schema is not None and not force_refresh:
+            return True
+            
+        try:
+            database = await self._client.get(f"databases/{self._database_id}")
+            if database and "properties" in database:
+                self._schema = database["properties"]
+                self.logger.debug("Loaded schema for database %s", self._database_id)
+                return True
+            else:
+                self.logger.error("Failed to load schema: missing 'properties' in response")
+                return False
+        except Exception as e:
+            self.logger.error("Error loading database schema: %s", str(e))
+            return False
+    
+    async def _ensure_schema_loaded(self) -> None:
+        """
+        Ensures the schema is loaded before accessing it.
+        """
+        if self._schema is None:
+            await self.load_schema()
+    
+    async def get_schema(self) -> Dict[str, Any]:
+        """
+        Gets the database schema.
+        
+        Returns:
+            Dict[str, Any]: The database schema
+        """
+        await self._ensure_schema_loaded()
+        return self._schema or {}
+    
+    async def get_property_types(self) -> Dict[str, str]:
+        """
+        Gets all property types for the database.
+        
+        Returns:
+            Dict[str, str]: Dictionary mapping property names to their types
+        """
+        await self._ensure_schema_loaded()
+        
+        if not self._schema:
+            return {}
+            
+        return {
+            prop_name: prop_data.get("type", "unknown")
+            for prop_name, prop_data in self._schema.items()
+        }
+    
+    async def get_property_schema(self, property_name: str) -> Optional[Dict[str, Any]]:
+        """
+        Gets the schema for a specific property.
+        
+        Args:
+            property_name: The name of the property
+            
+        Returns:
+            Optional[Dict[str, Any]]: The property schema or None if not found
+        """
+        await self._ensure_schema_loaded()
+        
+        if not self._schema or property_name not in self._schema:
+            return None
+            
+        return self._schema[property_name]
+    
+    async def get_property_type(self, property_name: str) -> Optional[str]:
+        """
+        Gets the type of a specific property.
+        
+        Args:
+            property_name: The name of the property
+            
+        Returns:
+            Optional[str]: The property type or None if not found
+        """
+        property_schema = await self.get_property_schema(property_name)
+        
+        if not property_schema:
+            return None
+            
+        return property_schema.get("type")
+    
+    async def property_exists(self, property_name: str) -> bool:
+        """
+        Checks if a property exists in the database.
+        
+        Args:
+            property_name: The name of the property
+            
+        Returns:
+            bool: True if the property exists, False otherwise
+        """
+        property_schema = await self.get_property_schema(property_name)
+        return property_schema is not None
+    
+    async def get_property_options(self, property_name: str) -> List[Dict[str, Any]]:
+        """
+        Gets the available options for a property (select, multi_select, status).
+        
+        Args:
+            property_name: The name of the property
+            
+        Returns:
+            List[Dict[str, Any]]: List of available options with their metadata
+        """
+        property_schema = await self.get_property_schema(property_name)
+        
+        if not property_schema:
+            return []
+            
+        property_type = property_schema.get("type")
+        
+        if property_type in ["select", "multi_select", "status"]:
+            return property_schema.get(property_type, {}).get("options", [])
+            
+        return []
+    
+    async def get_option_names(self, property_name: str) -> List[str]:
+        """
+        Gets the available option names for a property (select, multi_select, status).
+        
+        Args:
+            property_name: The name of the property
+            
+        Returns:
+            List[str]: List of available option names
+        """
+        options = await self.get_property_options(property_name)
+        return [option.get("name", "") for option in options]
+    
+    async def get_relation_details(self, property_name: str) -> Optional[Dict[str, Any]]:
+        """
+        Gets details about a relation property, including the related database.
+        
+        Args:
+            property_name: The name of the property
+            
+        Returns:
+            Optional[Dict[str, Any]]: The relation details or None if not a relation
+        """
+        property_schema = await self.get_property_schema(property_name)
+        
+        if not property_schema or property_schema.get("type") != "relation":
+            return None
+            
+        return property_schema.get("relation", {})
+    
+    async def get_relation_options(self, property_name: str, limit: int = 100) -> List[Dict[str, Any]]:
+        """
+        Gets available options for a relation property by querying the related database.
+        
+        Args:
+            property_name: The name of the relation property
+            limit: Maximum number of options to retrieve
+            
+        Returns:
+            List[Dict[str, Any]]: List of pages from the related database
+        """
+        relation_details = await self.get_relation_details(property_name)
+        
+        if not relation_details or "database_id" not in relation_details:
+            return []
+            
+        related_db_id = relation_details["database_id"]
+        
+        try:
+            # Query the related database to get options
+            query_result = await self._client.post(
+                f"databases/{related_db_id}/query",
+                {
+                    "page_size": limit,
+                }
+            )
+            
+            if not query_result or "results" not in query_result:
+                return []
+                
+            # Extract relevant information from each page
+            options = []
+            for page in query_result["results"]:
+                page_id = page.get("id")
+                title = self._extract_title_from_page(page)
+                
+                if page_id and title:
+                    options.append({
+                        "id": page_id,
+                        "name": title
+                    })
+                    
+            return options
+        except Exception as e:
+            self.logger.error(f"Error getting relation options: {str(e)}")
+            return []
+    
+    def _extract_title_from_page(self, page: Dict[str, Any]) -> Optional[str]:
+        """
+        Extracts the title from a page object.
+        
+        Args:
+            page: The page object from Notion API
+            
+        Returns:
+            Optional[str]: The page title or None if not found
+        """
+        if "properties" not in page:
+            return None
+            
+        properties = page["properties"]
+        
+        # Look for a title property
+        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 None
+    
+    async def validate_property_value(self, property_name: str, value: Any) -> Tuple[bool, Optional[str], Optional[List[str]]]:
+        """
+        Validates a value for a property.
+        
+        Args:
+            property_name: The name of the property
+            value: The value to validate
+            
+        Returns:
+            Tuple[bool, Optional[str], Optional[List[str]]]: 
+                - Boolean indicating if valid
+                - Error message if invalid
+                - Available options if applicable
+        """
+        property_schema = await self.get_property_schema(property_name)
+        
+        if not property_schema:
+            return False, f"Property '{property_name}' does not exist", None
+            
+        property_type = property_schema.get("type")
+        
+        # Validate select, multi_select, status properties
+        if property_type in ["select", "status"]:
+            options = await self.get_option_names(property_name)
+            
+            if isinstance(value, str) and value not in options:
+                return False, f"Invalid {property_type} option. Value '{value}' is not in the available options.", options
+                
+        elif property_type == "multi_select":
+            options = await self.get_option_names(property_name)
+            
+            if isinstance(value, list):
+                invalid_values = [val for val in value if val not in options]
+                if invalid_values:
+                    return False, f"Invalid multi_select options: {', '.join(invalid_values)}", options
+        
+        return True, None, None
+    
+    async def get_database_metadata(self, include_types: Optional[List[str]] = None) -> Dict[str, Any]:
+        """
+        Gets the complete metadata of the database, including property options.
+        
+        Args:
+            include_types: List of property types to include (if None, include all)
+            
+        Returns:
+            Dict[str, Any]: The database metadata
+        """
+        await self._ensure_schema_loaded()
+        
+        if not self._schema:
+            return {"properties": {}}
+            
+        metadata = {"properties": {}}
+        
+        for prop_name, prop_data in self._schema.items():
+            prop_type = prop_data.get("type")
+            
+            # Skip if we're filtering and this type isn't included
+            if include_types and prop_type not in include_types:
+                continue
+                
+            prop_metadata = {
+                "type": prop_type,
+                "options": []
+            }
+            
+            # Include options for select, multi_select, status
+            if prop_type in ["select", "multi_select", "status"]:
+                prop_metadata["options"] = prop_data.get(prop_type, {}).get("options", [])
+                
+            # For relation properties, we might want to include related database info
+            elif prop_type == "relation":
+                prop_metadata["relation_details"] = prop_data.get("relation", {})
+                
+            metadata["properties"][prop_name] = prop_metadata
+            
+        return metadata