notionary 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

notionary/core/database/notion_database_writer.py

@@ -0,0 +1,390 @@
+from typing import Any, Dict, List, Optional, Union, TypedDict, cast
+from notionary.core.database.notion_database_schema import NotionDatabaseSchema
+from notionary.core.notion_client import NotionClient
+from notionary.core.page.property_formatter import NotionPropertyFormatter
+from notionary.util.logging_mixin import LoggingMixin
+
+
+class NotionRelationItem(TypedDict):
+    id: str
+
+
+class NotionRelationProperty(TypedDict):
+    relation: List[NotionRelationItem]
+
+
+class NotionFormattedValue(TypedDict, total=False):
+    title: List[Dict[str, Any]]
+    rich_text: List[Dict[str, Any]]
+    select: Dict[str, str]
+    multi_select: List[Dict[str, str]]
+    relation: List[NotionRelationItem]
+    number: Union[int, float]
+    date: Dict[str, str]
+    checkbox: bool
+    url: str
+    email: str
+    phone_number: str
+
+
+class PageCreationResponse(TypedDict):
+    id: str
+    parent: Dict[str, str]
+    properties: Dict[str, Any]
+
+
+class NotionRelationHandler(LoggingMixin):
+    """
+    Handler for managing relations in Notion databases.
+    Provides a unified interface for working with relations.
+    """
+
+    def __init__(self, client: NotionClient, db_schema: NotionDatabaseSchema) -> None:
+        self._client = client
+        self._db_schema = db_schema
+        self._formatter = NotionPropertyFormatter()
+
+    async def find_relation_by_title(
+        self, database_id: str, relation_prop_name: str, title: str
+    ) -> Optional[str]:
+        """
+        Finds a relation ID based on the title of the entry in the target database.
+        """
+        target_db_id = await self._db_schema.get_relation_database_id(
+            relation_prop_name
+        )
+        if not target_db_id:
+            self.logger.error(
+                "No target database found for relation '%s' in database %s",
+                relation_prop_name,
+                database_id,
+            )
+            return None
+
+        options = await self._db_schema.get_relation_options(relation_prop_name)
+
+        for option in options:
+            if option["title"].lower() == title.lower():
+                self.logger.debug("Relation entry '%s' found: %s", title, option["id"])
+                return option["id"]
+
+        self.logger.warning("Relation entry '%s' not found", title)
+        return None
+
+    async def _get_title_properties(
+        self, database_id: str, title: str
+    ) -> Optional[Dict[str, NotionFormattedValue]]:
+        """
+        Determines the title property for a database and formats the value.
+        """
+        if not await self._db_schema.load():
+            self.logger.error("Could not load database schema for %s", database_id)
+            return None
+
+        property_types = await self._db_schema.get_property_types()
+
+        title_prop_name: Optional[str] = None
+        for name, prop_type in property_types.items():
+            if prop_type == "title":
+                title_prop_name = name
+                break
+
+        if not title_prop_name:
+            self.logger.error("No title property found in database %s", database_id)
+            return None
+
+        formatted_title = self._formatter.format_value("title", title)
+        if not formatted_title:
+            self.logger.error("Could not format title '%s'", title)
+            return None
+
+        return {title_prop_name: cast(NotionFormattedValue, formatted_title)}
+
+
+class DatabaseWritter(LoggingMixin):
+    """
+    Enhanced class for creating and updating pages in Notion databases.
+    Supports both simple properties and relations.
+    """
+
+    def __init__(
+        self, client: NotionClient, db_schema: Optional[NotionDatabaseSchema] = None
+    ) -> None:
+        """
+        Initialize with a NotionClient and optionally a NotionDatabaseSchema.
+
+        Args:
+            client: The Notion API client
+            db_schema: Optional database schema instance
+        """
+        self._client = client
+        self._formatter = NotionPropertyFormatter()
+
+        self._active_schema: Optional[NotionDatabaseSchema] = db_schema
+        self._relation_handler: Optional[NotionRelationHandler] = None
+
+        if db_schema:
+            self._relation_handler = NotionRelationHandler(client, db_schema)
+
+    async def _ensure_schema_for_database(self, database_id: str) -> bool:
+        """
+        Stellt sicher, dass ein Schema für die angegebene Datenbank geladen ist.
+
+        Args:
+            database_id: ID der Datenbank
+
+        Returns:
+            True, wenn das Schema erfolgreich geladen wurde
+        """
+        if self._active_schema and self._active_schema.database_id == database_id:
+            return True
+
+        self._active_schema = NotionDatabaseSchema(database_id, self._client)
+        self._relation_handler = NotionRelationHandler(
+            self._client, self._active_schema
+        )
+
+        return await self._active_schema.load()
+
+    async def create_page(
+        self,
+        database_id: str,
+        properties: Dict[str, Any],
+        relations: Optional[Dict[str, Union[str, List[str]]]] = None,
+    ) -> Optional[PageCreationResponse]:
+        """
+        Creates a new page in a database with support for relations.
+        """
+        # Stelle sicher, dass wir ein Schema für diese Datenbank haben
+        if not await self._ensure_schema_for_database(database_id):
+            self.logger.error("Could not load schema for database %s", database_id)
+            return None
+
+        formatted_props = await self._format_properties(database_id, properties)
+        if not formatted_props:
+            return None
+
+        if relations:
+            relation_props = await self._process_relations(database_id, relations)
+            if relation_props:
+                formatted_props.update(relation_props)
+
+        data: Dict[str, Any] = {
+            "parent": {"database_id": database_id},
+            "properties": formatted_props,
+        }
+
+        result = await self._client.post("pages", data)
+        if not result:
+            self.logger.error("Error creating page in database %s", database_id)
+            return None
+
+        self.logger.info("Page successfully created in database %s", database_id)
+        return cast(PageCreationResponse, result)
+
+    async def update_page(
+        self,
+        page_id: str,
+        properties: Optional[Dict[str, Any]] = None,
+        relations: Optional[Dict[str, Union[str, List[str]]]] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Updates a page with support for relations.
+        """
+        page_data = await self._client.get(f"pages/{page_id}")
+        if (
+            not page_data
+            or "parent" not in page_data
+            or "database_id" not in page_data["parent"]
+        ):
+            self.logger.error("Could not determine database ID for page %s", page_id)
+            return None
+
+        database_id = page_data["parent"]["database_id"]
+
+        # Stelle sicher, dass wir ein Schema für diese Datenbank haben
+        if not await self._ensure_schema_for_database(database_id):
+            self.logger.error("Could not load schema for database %s", database_id)
+            return None
+
+        if not properties and not relations:
+            self.logger.warning("No properties or relations specified for update")
+            return page_data
+
+        update_props: Dict[str, NotionFormattedValue] = {}
+
+        if properties:
+            formatted_props = await self._format_properties(database_id, properties)
+            if formatted_props:
+                update_props.update(formatted_props)
+
+        if relations:
+            relation_props = await self._process_relations(database_id, relations)
+            if relation_props:
+                update_props.update(relation_props)
+
+        if not update_props:
+            self.logger.warning("No valid properties to update for page %s", page_id)
+            return None
+
+        data = {"properties": update_props}
+
+        result = await self._client.patch(f"pages/{page_id}", data)
+        if not result:
+            self.logger.error("Error updating page %s", page_id)
+            return None
+
+        self.logger.info("Page %s successfully updated", page_id)
+        return result
+
+    async def delete_page(self, page_id: str) -> bool:
+        """
+        Deletes a page (archives it in Notion).
+        """
+        data = {"archived": True}
+
+        result = await self._client.patch(f"pages/{page_id}", data)
+        if not result:
+            self.logger.error("Error deleting page %s", page_id)
+            return False
+
+        self.logger.info("Page %s successfully deleted (archived)", page_id)
+        return True
+
+    async def _format_properties(
+        self, database_id: str, properties: Dict[str, Any]
+    ) -> Optional[Dict[str, NotionFormattedValue]]:
+        """
+        Formats properties according to their types in the database.
+        """
+        if not self._active_schema:
+            self.logger.error("No active schema available for database %s", database_id)
+            return None
+
+        property_types = await self._active_schema.get_property_types()
+        if not property_types:
+            self.logger.error(
+                "Could not get property types for database %s", database_id
+            )
+            return None
+
+        formatted_props: Dict[str, NotionFormattedValue] = {}
+
+        for prop_name, value in properties.items():
+            if prop_name not in property_types:
+                self.logger.warning(
+                    "Property '%s' does not exist in database %s",
+                    prop_name,
+                    database_id,
+                )
+                continue
+
+            prop_type = property_types[prop_name]
+
+            formatted_value = self._formatter.format_value(prop_type, value)
+            if formatted_value:
+                formatted_props[prop_name] = cast(NotionFormattedValue, formatted_value)
+            else:
+                self.logger.warning(
+                    "Could not format value for property '%s' of type '%s'",
+                    prop_name,
+                    prop_type,
+                )
+
+        return formatted_props
+
+    async def _process_relations(
+        self, database_id: str, relations: Dict[str, Union[str, List[str]]]
+    ) -> Dict[str, NotionRelationProperty]:
+        """
+        Processes relation properties and converts titles to IDs.
+        """
+        if not self._relation_handler:
+            self.logger.error("No relation handler available")
+            return {}
+
+        formatted_relations: Dict[str, NotionRelationProperty] = {}
+        property_types = (
+            await self._active_schema.get_property_types()
+            if self._active_schema
+            else {}
+        )
+
+        for prop_name, titles in relations.items():
+            relation_property = await self._process_single_relation(
+                database_id, prop_name, titles, property_types
+            )
+            if relation_property:
+                formatted_relations[prop_name] = relation_property
+
+        return formatted_relations
+
+    async def _process_single_relation(
+        self,
+        database_id: str,
+        prop_name: str,
+        titles: Union[str, List[str]],
+        property_types: Dict[str, str],
+    ) -> Optional[NotionRelationProperty]:
+        """
+        Process a single relation property and convert titles to IDs.
+
+        Args:
+            database_id: The database ID
+            prop_name: The property name
+            titles: The title or list of titles to convert
+            property_types: Dictionary of property types
+
+        Returns:
+            A formatted relation property or None if invalid
+        """
+        if prop_name not in property_types:
+            self.logger.warning(
+                "Property '%s' does not exist in database %s", prop_name, database_id
+            )
+            return None
+
+        prop_type = property_types[prop_name]
+        if prop_type != "relation":
+            self.logger.warning(
+                "Property '%s' is not a relation (type: %s)", prop_name, prop_type
+            )
+            return None
+
+        title_list: List[str] = [titles] if isinstance(titles, str) else titles
+        relation_ids = await self._get_relation_ids(database_id, prop_name, title_list)
+
+        if not relation_ids:
+            return None
+
+        return {"relation": [{"id": rel_id} for rel_id in relation_ids]}
+
+    async def _get_relation_ids(
+        self, database_id: str, prop_name: str, titles: List[str]
+    ) -> List[str]:
+        """
+        Get relation IDs for a list of titles.
+
+        Args:
+            database_id: The database ID
+            prop_name: The property name
+            titles: List of titles to convert
+
+        Returns:
+            List of relation IDs
+        """
+        relation_ids: List[str] = []
+
+        for title in titles:
+            relation_id = await self._relation_handler.find_relation_by_title(
+                database_id, prop_name, title
+            )
+
+            if relation_id:
+                relation_ids.append(relation_id)
+            else:
+                self.logger.warning(
+                    "Could not find relation ID for '%s' in '%s'", title, prop_name
+                )
+
+        return relation_ids

notionary/core/database/page_service.py

@@ -0,0 +1,161 @@
+from typing import Dict, Optional, Any, List, Union, TYPE_CHECKING
+from notionary.core.database.models.page_result import PageResult
+from notionary.core.database.notion_database_schema import NotionDatabaseSchema
+from notionary.core.database.notion_database_writer import DatabaseWritter
+from notionary.core.notion_client import NotionClient
+
+from notionary.core.page.notion_page_manager import NotionPageManager
+from notionary.exceptions.database_exceptions import (
+    PageNotFoundException,
+    PageOperationError,
+)
+from notionary.exceptions.page_creation_exception import PageCreationException
+from notionary.util.uuid_utils import format_uuid
+
+
+class DatabasePageService:
+    """Service für den Umgang mit Datenbankseiten"""
+
+    def __init__(
+        self,
+        client: NotionClient,
+        schema: NotionDatabaseSchema,
+        writer: DatabaseWritter,
+    ):
+        self._client = client
+        self._schema = schema
+        self._writer = writer
+
+    def _format_page_id(self, page_id: str) -> str:
+        """
+        Format a page ID to ensure it's in the correct format.
+
+        Args:
+            page_id: The page ID to format
+
+        Returns:
+            The formatted page ID
+        """
+        return format_uuid(page_id) or page_id
+
+    async def create_page(
+        self,
+        database_id: str,
+        properties: Dict[str, Any],
+        relations: Optional[Dict[str, Union[str, List[str]]]] = None,
+    ) -> PageResult:
+        """
+        Create a new page in the database.
+
+        Args:
+            database_id: The database ID to create the page in
+            properties: Dictionary of property names and values
+            relations: Optional dictionary of relation property names and titles
+
+        Returns:
+            Result object with success status and page information
+        """
+        try:
+            response = await self._writer.create_page(
+                database_id, properties, relations
+            )
+
+            if not response:
+                return {
+                    "success": False,
+                    "message": f"Failed to create page in database {database_id}",
+                }
+
+            page_id = response.get("id", "")
+            page_url = response.get("url", None)
+
+            return {"success": True, "page_id": page_id, "url": page_url}
+
+        except PageCreationException as e:
+            return {"success": False, "message": str(e)}
+
+    async def update_page(
+        self,
+        page_id: str,
+        properties: Optional[Dict[str, Any]] = None,
+        relations: Optional[Dict[str, Union[str, List[str]]]] = None,
+    ) -> PageResult:
+        """
+        Update an existing page.
+
+        Args:
+            page_id: The ID of the page to update
+            properties: Dictionary of property names and values to update
+            relations: Optional dictionary of relation property names and titles
+
+        Returns:
+            Result object with success status and message
+        """
+        try:
+            formatted_page_id = self._format_page_id(page_id)
+
+            response = await self._writer.update_page(
+                formatted_page_id, properties, relations
+            )
+
+            if not response:
+                return {
+                    "success": False,
+                    "message": f"Failed to update page {formatted_page_id}",
+                }
+
+            return {"success": True, "page_id": formatted_page_id}
+
+        except PageOperationError as e:
+            return {"success": False, "message": f"Error: {str(e)}"}
+
+    async def delete_page(self, page_id: str) -> PageResult:
+        """
+        Delete (archive) a page.
+
+        Args:
+            page_id: The ID of the page to delete
+
+        Returns:
+            Result object with success status and message
+        """
+        try:
+            formatted_page_id = self._format_page_id(page_id)
+
+            success = await self._writer.delete_page(formatted_page_id)
+
+            if not success:
+                return {
+                    "success": False,
+                    "message": f"Failed to delete page {formatted_page_id}",
+                }
+
+            return {"success": True, "page_id": formatted_page_id}
+
+        except PageOperationError as e:
+            return {"success": False, "message": f"Error: {str(e)}"}
+
+    async def get_page_manager(self, page_id: str) -> Optional[NotionPageManager]:
+        """
+        Get a NotionPageManager for a specific page.
+
+        Args:
+            page_id: The ID of the page
+
+        Returns:
+            NotionPageManager instance or None if the page wasn't found
+        """
+        formatted_page_id = self._format_page_id(page_id)
+
+        try:
+            page_data = await self._client.get(f"pages/{formatted_page_id}")
+
+            if not page_data:
+                return None
+
+            return NotionPageManager(
+                page_id=formatted_page_id, url=page_data.get("url")
+            )
+
+        except PageNotFoundException:
+            return None

notionary/core/notion_client.py

@@ -0,0 +1,134 @@
+import asyncio
+import os
+from enum import Enum
+from typing import Dict, Any, Optional, Union
+import httpx
+from dotenv import load_dotenv
+from notionary.util.logging_mixin import LoggingMixin
+import weakref
+
+
+class HttpMethod(Enum):
+    """Enum für HTTP-Methoden."""
+
+    GET = "get"
+    POST = "post"
+    PATCH = "patch"
+    DELETE = "delete"
+
+
+class NotionClient(LoggingMixin):
+    """Verbesserter Notion-Client mit automatischer Ressourcenverwaltung."""
+
+    BASE_URL = "https://api.notion.com/v1"
+    NOTION_VERSION = "2022-06-28"
+    _instances = weakref.WeakSet()
+
+    def __init__(self, token: Optional[str] = None, timeout: int = 30):
+        load_dotenv()
+        self.token = token or os.getenv("NOTION_SECRET", "")
+        if not self.token:
+            raise ValueError("Notion API token is required")
+
+        self.headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json",
+            "Notion-Version": self.NOTION_VERSION,
+        }
+
+        self.client = httpx.AsyncClient(headers=self.headers, timeout=timeout)
+
+        self._instances.add(self)
+
+    @classmethod
+    async def close_all(cls):
+        for instance in list(cls._instances):
+            await instance.close()
+
+    async def close(self):
+        if hasattr(self, "client") and self.client:
+            await self.client.aclose()
+            self.client = None
+
+    async def get(self, endpoint: str) -> Optional[Dict[str, Any]]:
+        return await self._make_request(HttpMethod.GET, endpoint)
+
+    async def post(
+        self, endpoint: str, data: Optional[Dict[str, Any]] = None
+    ) -> Optional[Dict[str, Any]]:
+        return await self._make_request(HttpMethod.POST, endpoint, data)
+
+    async def patch(
+        self, endpoint: str, data: Optional[Dict[str, Any]] = None
+    ) -> Optional[Dict[str, Any]]:
+        return await self._make_request(HttpMethod.PATCH, endpoint, data)
+
+    async def delete(self, endpoint: str) -> bool:
+        result = await self._make_request(HttpMethod.DELETE, endpoint)
+        return result is not None
+
+    async def _make_request(
+        self,
+        method: Union[HttpMethod, str],
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Führt eine HTTP-Anfrage aus und gibt direkt die Daten zurück oder None bei Fehler.
+        """
+        url = f"{self.BASE_URL}/{endpoint.lstrip('/')}"
+        method_str = (
+            method.value if isinstance(method, HttpMethod) else str(method).lower()
+        )
+
+        try:
+            self.logger.debug("Sending %s request to %s", method_str.upper(), url)
+
+            if (
+                method_str in [HttpMethod.POST.value, HttpMethod.PATCH.value]
+                and data is not None
+            ):
+                response = await getattr(self.client, method_str)(url, json=data)
+            else:
+                response = await getattr(self.client, method_str)(url)
+
+            response.raise_for_status()
+            result_data = response.json()
+            self.logger.debug("Request successful: %s", url)
+            return result_data
+
+        except httpx.HTTPStatusError as e:
+            error_msg = (
+                f"HTTP status error: {e.response.status_code} - {e.response.text}"
+            )
+            self.logger.error("Request failed (%s): %s", url, error_msg)
+            return None
+
+        except httpx.RequestError as e:
+            error_msg = f"Request error: {str(e)}"
+            self.logger.error("Request error (%s): %s", url, error_msg)
+            return None
+
+    def __del__(self):
+        """
+        Destruktor, der beim Garbage Collecting aufgerufen wird.
+
+        Hinweis: Dies ist nur ein Fallback, da __del__ nicht garantiert für async Cleanup funktioniert.
+        Die bessere Praxis ist, close() explizit zu rufen, wenn möglich.
+        """
+        if not hasattr(self, "client") or not self.client:
+            return
+
+        try:
+            loop = asyncio.get_event_loop()
+            if not loop.is_running():
+                self.logger.warning(
+                    "Event loop not running, could not auto-close NotionClient"
+                )
+                return
+
+            # Versuche, Cleanup Task zu erstellen
+            loop.create_task(self.close())
+            self.logger.debug("Created cleanup task for NotionClient")
+        except RuntimeError:
+            self.logger.warning("No event loop available for auto-closing NotionClient")