notionary 0.2.12__py3-none-any.whl → 0.2.14__py3-none-any.whl

notionary/page/properites/database_property_service.py

@@ -1,302 +0,0 @@
-from typing import Dict, List, Optional, Any, Tuple
-from notionary.notion_client import NotionClient
-from notionary.util 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: bool = False) -> bool:
-        """
-        Loads the database schema.
-
-        Args:
-            force_refresh: Whether to force a refresh of the schema
-
-        Returns:
-            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_database(self._database_id)
-
-            self._schema = database.properties
-            self.logger.debug("Loaded schema for database %s", self._database_id)
-            return True
-
-        except Exception as e:
-            self.logger.error(
-                "Error loading database schema for %s: %s", self._database_id, 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

notionary/page/properites/page_property_manager.py

@@ -1,152 +0,0 @@
-from typing import Dict, Any, List, Optional
-from notionary.models.notion_page_response import NotionPageResponse
-from notionary.notion_client import NotionClient
-from notionary.page.metadata.metadata_editor import MetadataEditor
-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 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()
-
-    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
-    ) -> Optional[Any]:
-        """
-        Set a property value by name, automatically detecting the property type.
-
-        Args:
-            property_name: Name of the property
-            value: Value to set
-
-        Returns:
-            Optional[Any]: The new value if successful, None if failed
-        """
-        property_type = await self.get_property_type(property_name)
-
-        if property_type == "relation":
-            self.logger.warning(
-                "Property '%s' is of type 'relation'. Relations must be set using the RelationManager.",
-                property_name,
-            )
-            return None
-
-        is_db_page = await self._db_relation.is_database_page()
-        db_service = None
-
-        if is_db_page:
-            db_service = await self._init_db_property_service()
-
-        if db_service:
-            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)
-                    self.logger.warning(
-                        "%s\nAvailable options for '%s': '%s'",
-                        error_message,
-                        property_name,
-                        options_str,
-                    )
-                else:
-                    self.logger.warning(
-                        "%s\nNo valid options available for '%s'",
-                        error_message,
-                        property_name,
-                    )
-                return None
-
-        api_response = await self._metadata_editor.set_property_by_name(
-            property_name, value
-        )
-
-        if api_response:
-            await self.invalidate_cache()
-            return value
-
-        self.logger.warning(
-            "Failed to set property '%s' (no API response)", property_name
-        )
-        return None
-
-    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) -> NotionPageResponse:
-        """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
-
-    async def _get_properties(self) -> Dict[str, Any]:
-        """Retrieves all properties of the page."""
-        page_data = await self._get_page_data()
-        return page_data.properties if page_data.properties else {}