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

notionary/core/database/notion_database_schema.py

@@ -1,75 +1,12 @@
 from typing import (
     AsyncGenerator,
     Dict,
-    List,
     Optional,
     Any,
-    TypedDict,
-    Union,
-    cast,
-    Literal,
 )
 from notionary.core.notion_client import NotionClient
-from notionary.core.page.notion_page_manager import NotionPageManager
 from notionary.util.logging_mixin import LoggingMixin
 
-
-class NotionTextContent(TypedDict):
-    plain_text: str
-
-
-class NotionTitleProperty(TypedDict):
-    type: Literal["title"]
-    title: List[NotionTextContent]
-
-
-class NotionSelectOption(TypedDict):
-    name: str
-    id: Optional[str]
-    color: Optional[str]
-
-
-class NotionSelectProperty(TypedDict):
-    type: Literal["select"]
-    select: Dict[str, List[NotionSelectOption]]
-
-
-class NotionMultiSelectProperty(TypedDict):
-    type: Literal["multi_select"]
-    multi_select: Dict[str, List[NotionSelectOption]]
-
-
-class NotionStatusProperty(TypedDict):
-    type: Literal["status"]
-    status: Dict[str, List[NotionSelectOption]]
-
-
-class NotionRelationProperty(TypedDict):
-    type: Literal["relation"]
-    relation: Dict[str, str]
-
-
-class NotionNumberProperty(TypedDict):
-    type: Literal["number"]
-    number: Dict[str, Any]
-
-
-NotionPropertyType = Union[
-    NotionTitleProperty,
-    NotionSelectProperty,
-    NotionMultiSelectProperty,
-    NotionStatusProperty,
-    NotionRelationProperty,
-    NotionNumberProperty,
-    Dict[str, Any],  # Fallback
-]
-
-
-class RelationOption(TypedDict):
-    id: str
-    title: str
-
-
 class NotionDatabaseAccessor(LoggingMixin):
     """
     A utility class that provides methods to access Notion databases.
@@ -164,254 +101,4 @@ class NotionDatabaseAccessor(LoggingMixin):
             if title_parts:
                 title = "".join(title_parts)
 
-        return title
-
-
-class NotionDatabaseSchema:
-    """
-    Represents the schema of a specific Notion database.
-    Manages property information, options, and relations for a single database.
-    """
-
-    def __init__(self, database_id: str, client: NotionClient) -> None:
-        """
-        Initialize a database schema handler for a specific database.
-
-        Args:
-            database_id: The ID of the database
-            client: An instance of NotionClient for API requests
-        """
-        self.database_id: str = database_id
-        self._client: NotionClient = client
-        self._properties: Dict[str, NotionPropertyType] = {}
-        self._loaded: bool = False
-
-    async def load(self) -> bool:
-        """
-        Load the database schema from the Notion API.
-
-        Returns:
-            True if the schema was loaded successfully, False otherwise
-        """
-        if self._loaded:
-            return True
-
-        db_details = await self._client.get(f"databases/{self.database_id}")
-        if not db_details or "properties" not in db_details:
-            return False
-
-        self._properties = db_details["properties"]
-        self._loaded = True
-        return True
-
-    async def get_property_types(self) -> Dict[str, str]:
-        """
-        Get a mapping of property names to their types.
-
-        Returns:
-            A dictionary mapping property names to types
-        """
-        if not self._loaded:
-            await self.load()
-
-        return {name: prop.get("type", "") for name, prop in self._properties.items()}
-
-    async def get_select_options(self, property_name: str) -> List[NotionSelectOption]:
-        """
-        Get the options for a select, multi_select, or status property.
-
-        Args:
-            property_name: The name of the property
-
-        Returns:
-            A list of option objects
-        """
-        if not self._loaded:
-            await self.load()
-
-        if property_name not in self._properties:
-            return []
-
-        prop = self._properties[property_name]
-        prop_type = prop.get("type", "")
-
-        if prop_type not in ["select", "multi_select", "status"]:
-            return []
-
-        if prop_type in prop and "options" in prop[prop_type]:
-            return cast(List[NotionSelectOption], prop[prop_type]["options"])
-
-        return []
-
-    async def get_relation_options(
-        self, property_name: str, limit: int = 100
-    ) -> List[RelationOption]:
-        """
-        Get available options for a relation property (pages in the related database).
-
-        Args:
-            property_name: The name of the relation property
-            limit: Maximum number of options to retrieve
-
-        Returns:
-            List of options with id and title
-        """
-        related_db_id = await self.get_relation_database_id(property_name)
-        if not related_db_id:
-            return []
-
-        pages = await self._query_database_pages(related_db_id, limit)
-        return self._extract_page_titles_and_ids(pages)
-
-    async def get_relation_database_id(self, property_name: str) -> Optional[str]:
-        """
-        Get the ID of the related database for a relation property.
-
-        Args:
-            property_name: The name of the property
-
-        Returns:
-            The ID of the related database or None
-        """
-        if not self._loaded:
-            await self.load()
-
-        if property_name not in self._properties:
-            return None
-
-        prop = self._properties[property_name]
-        prop_type = prop.get("type", "")
-
-        if prop_type != "relation" or "relation" not in prop:
-            return None
-
-        relation_prop = cast(NotionRelationProperty, prop)
-        return relation_prop["relation"].get("database_id")
-
-    def _extract_page_titles_and_ids(
-        self, pages: List[NotionPageManager]
-    ) -> List[RelationOption]:
-        """
-        Extract titles and IDs from page objects.
-
-        Args:
-            pages: List of page objects from the Notion API
-
-        Returns:
-            List of dictionaries with id and title for each page
-        """
-        options: List[RelationOption] = []
-
-        for page_manager in pages:
-            page_title = page_manager.title or "Untitled"
-            options.append({"id": page_manager.page_id, "title": page_title})
-
-        return options
-
-    async def _query_database_pages(
-        self, database_id: str, limit: int = 100
-    ) -> List[Dict[str, Any]]:
-        """
-        Returns:
-            List of page objects from the Notion API
-        """
-        pages: List[Dict[str, Any]] = []
-        count = 0
-
-        async for page in self.iter_database_pages(
-            database_id=database_id, page_size=min(limit, 100)
-        ):
-            pages.append(page)
-            count += 1
-
-            if count >= limit:
-                break
-
-        return pages
-
-    async def iter_database_pages(
-        self,
-        database_id: Optional[str] = None,
-        page_size: int = 100,
-        filter_conditions: Optional[Dict[str, Any]] = None,
-        sorts: Optional[List[Dict[str, Any]]] = None,
-    ) -> AsyncGenerator[NotionPageManager, None]:
-        """
-        Asynchronous generator that yields pages from a Notion database one by one.
-
-        Uses the Notion API to provide paginated access to all pages in a database
-        without loading all of them into memory at once.
-
-        Args:
-            database_id: The ID of the database to query (uses self.database_id if None)
-            page_size: The number of pages to fetch per request
-            filter_conditions: Optional filter to apply to the database query
-            sorts: Optional sort instructions for the database query
-
-        Yields:
-            Individual page objects from the Notion API
-        """
-        db_id = database_id or self.database_id
-        if not db_id:
-            raise ValueError("No database ID provided")
-
-        start_cursor: Optional[str] = None
-        has_more = True
-
-        body: Dict[str, Any] = {"page_size": page_size}
-
-        if filter_conditions:
-            body["filter"] = filter_conditions
-
-        if sorts:
-            body["sorts"] = sorts
-
-        while has_more:
-            current_body = body.copy()
-            if start_cursor:
-                current_body["start_cursor"] = start_cursor
-
-            result = await self._client.post(
-                f"databases/{db_id}/query", data=current_body
-            )
-
-            if not result or "results" not in result:
-                return
-
-            for page in result["results"]:
-                page_id: str = page.get("id", "")
-                title = self._extract_page_title(page)
-                
-                page_url = f"https://notion.so/{page_id.replace('-', '')}"
-
-                notion_page_manager = NotionPageManager(page_id=page_id, title=title, url=page_url)
-                yield notion_page_manager
-
-            has_more = result.get("has_more", False)
-            start_cursor = result.get("next_cursor") if has_more else None
-
-    def _extract_page_title(self, page: Dict[str, Any]) -> str:
-        """
-        Extracts the title from a Notion page object.
-
-        Args:
-            page: The Notion page object
-
-        Returns:
-            The extracted title as a string, or an empty string if no title found
-        """
-        properties = page.get("properties", {})
-        if not properties:
-            return ""
-
-        for prop_value in properties.values():
-            if prop_value.get("type") != "title":
-                continue
-
-            title_array = prop_value.get("title", [])
-            if not title_array:
-                continue
-
-            return title_array[0].get("plain_text", "")
-
-        return ""
+        return title

notionary/core/notion_client.py

@@ -1,12 +1,11 @@
 import asyncio
 import os
+import weakref
 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."""
@@ -16,7 +15,6 @@ class HttpMethod(Enum):
     PATCH = "patch"
     DELETE = "delete"
 
-
 class NotionClient(LoggingMixin):
     """Verbesserter Notion-Client mit automatischer Ressourcenverwaltung."""
 
@@ -113,12 +111,6 @@ class NotionClient(LoggingMixin):
             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
 
@@ -134,4 +126,4 @@ class NotionClient(LoggingMixin):
             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")
+            self.logger.warning("No event loop available for auto-closing NotionClient")

notionary/core/page/{page_content_manager.py → content/page_content_manager.py}

@@ -48,26 +48,30 @@ class PageContentManager(LoggingMixin):
             return "No content to delete."
 
         deleted = 0
-        for b in results:
-            if await self._client.delete(f"blocks/{b['id']}"):
+        skipped = 0
+        for block in results:
+            if block.get("type") in ["child_database", "database", "linked_database"]:
+                skipped += 1
+                continue
+                
+            if await self._client.delete(f"blocks/{block['id']}"):
                 deleted += 1
 
-        return f"Deleted {deleted}/{len(results)} blocks."
+        return f"Deleted {deleted}/{len(results)} blocks. Skipped {skipped} database blocks."
 
-    # Methods from PageContentReader
     async def get_blocks(self) -> List[Dict[str, Any]]:
         result = await self._client.get(f"blocks/{self.page_id}/children")
         if not result:
             self.logger.error("Error retrieving page content: %s", result.error)
             return []
-        return result.data.get("results", [])
+        return result.get("results", [])
 
     async def get_block_children(self, block_id: str) -> List[Dict[str, Any]]:
         result = await self._client.get(f"blocks/{block_id}/children")
         if not result:
             self.logger.error("Error retrieving block children: %s", result.error)
             return []
-        return result.data.get("results", [])
+        return result.get("results", [])
 
     async def get_page_blocks_with_children(self) -> List[Dict[str, Any]]:
         blocks = await self.get_blocks()

notionary/core/page/metadata/metadata_editor.py

@@ -0,0 +1,109 @@
+from typing import Any, Dict, Optional
+from notionary.core.notion_client import NotionClient
+from notionary.core.page.properites.property_formatter import NotionPropertyFormatter
+from notionary.util.logging_mixin import LoggingMixin
+
+
+class MetadataEditor(LoggingMixin):
+    def __init__(self, page_id: str, client: NotionClient):
+        self.page_id = page_id
+        self._client = client
+        self._property_formatter = NotionPropertyFormatter()
+
+    async def set_title(self, title: str) -> Optional[Dict[str, Any]]:
+        return await self._client.patch(
+            f"pages/{self.page_id}",
+            {
+                "properties": {
+                    "title": {"title": [{"type": "text", "text": {"content": title}}]}
+                }
+            },
+        )
+
+    async def set_property(self, property_name: str, property_value: Any, property_type: str) -> Optional[Dict[str, Any]]:
+            """
+            Generic method to set any property on a Notion page.
+            
+            Args:
+                property_name: The name of the property in Notion
+                property_value: The value to set
+                property_type: The type of property ('select', 'multi_select', 'status', 'relation', etc.)
+                
+            Returns:
+                Optional[Dict[str, Any]]: The API response or None if the operation fails
+            """
+            property_payload = self._property_formatter.format_value(property_type, property_value)
+            
+            if not property_payload:
+                self.logger.warning("Could not create payload for property type: %s", property_type)
+                return None
+                
+            return await self._client.patch(
+                f"pages/{self.page_id}",
+                {
+                    "properties": {
+                        property_name: property_payload
+                    }
+                },
+            )
+
+
+    async def get_property_schema(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Retrieves the schema for all properties of the page.
+        
+        Returns:
+            Dict[str, Dict[str, Any]]: A dictionary mapping property names to their schema
+        """
+        page_data = await self._client.get_page(self.page_id)
+        property_schema = {}
+        
+        if not page_data or "properties" not in page_data:
+            return property_schema
+            
+        for prop_name, prop_data in page_data["properties"].items():
+            prop_type = prop_data.get("type")
+            property_schema[prop_name] = {
+                "id": prop_data.get("id"),
+                "type": prop_type,
+                "name": prop_name
+            }
+            
+            try:
+                if prop_type == "select" and "select" in prop_data:
+                    # Make sure prop_data["select"] is a dictionary before calling .get()
+                    if isinstance(prop_data["select"], dict):
+                        property_schema[prop_name]["options"] = prop_data["select"].get("options", [])
+                elif prop_type == "multi_select" and "multi_select" in prop_data:
+                    # Make sure prop_data["multi_select"] is a dictionary before calling .get()
+                    if isinstance(prop_data["multi_select"], dict):
+                        property_schema[prop_name]["options"] = prop_data["multi_select"].get("options", [])
+                elif prop_type == "status" and "status" in prop_data:
+                    # Make sure prop_data["status"] is a dictionary before calling .get()
+                    if isinstance(prop_data["status"], dict):
+                        property_schema[prop_name]["options"] = prop_data["status"].get("options", [])
+            except Exception as e:
+                if hasattr(self, 'logger') and self.logger:
+                    self.logger.warning("Error processing property schema for '%s': %s", prop_name, e)
+                
+        return property_schema
+        
+    async def set_property_by_name(self, property_name: str, value: Any) -> Optional[Dict[str, Any]]:
+        """
+        Sets a property value based on the property name, automatically detecting the property type.
+        
+        Args:
+            property_name: The name of the property in Notion
+            value: The value to set
+            
+        Returns:
+            Optional[Dict[str, Any]]: The API response or None if the operation fails
+        """
+        property_schema = await self.get_property_schema()
+        
+        if property_name not in property_schema:
+            self.logger.warning("Property '%s' not found in database schema", property_name)
+            return None
+            
+        property_type = property_schema[property_name]["type"]
+        return await self.set_property(property_name, value, property_type)

notionary/core/page/metadata/notion_icon_manager.py

@@ -0,0 +1,46 @@
+from typing import Any, Dict, Optional
+
+from notionary.core.notion_client import NotionClient
+from notionary.util.logging_mixin import LoggingMixin
+
+class NotionPageIconManager(LoggingMixin):
+    def __init__(self, page_id: str, client: NotionClient):
+        self.page_id = page_id
+        self._client = client
+        
+    async def set_icon(
+        self, emoji: Optional[str] = None, external_url: Optional[str] = None
+    ) -> Optional[Dict[str, Any]]:
+        if emoji:
+            icon = {"type": "emoji", "emoji": emoji}
+        elif external_url:
+            icon = {"type": "external", "external": {"url": external_url}}
+        else:
+            return None
+
+        return await self._client.patch(f"pages/{self.page_id}", {"icon": icon})
+    
+    
+    async def get_icon(self) -> Optional[str]:
+        """
+        Retrieves the page icon - either emoji or external URL.
+        
+        Returns:
+            str: Emoji character or URL if set, None if no icon
+        """
+        page_data = await self._client.get_page(self.page_id)
+        
+        if not page_data or "icon" not in page_data:
+            return None
+        
+        icon_data = page_data.get("icon", {})
+        icon_type = icon_data.get("type")
+        
+        if icon_type == "emoji":
+            return icon_data.get("emoji")
+        elif icon_type == "external":
+            return icon_data.get("external", {}).get("url")
+        
+        return None  
+    
+    

notionary/core/page/{meta_data/metadata_editor.py → metadata/notion_page_cover_manager.py}

@@ -1,48 +1,25 @@
+
 import random
 from typing import Any, Dict, Optional
 from notionary.core.notion_client import NotionClient
 from notionary.util.logging_mixin import LoggingMixin
 
-
-class MetadataEditor(LoggingMixin):
+class NotionPageCoverManager(LoggingMixin):
     def __init__(self, page_id: str, client: NotionClient):
         self.page_id = page_id
         self._client = client
-
-    async def set_title(self, title: str) -> Optional[Dict[str, Any]]:
-        return await self._client.patch(
-            f"pages/{self.page_id}",
-            {
-                "properties": {
-                    "title": {"title": [{"type": "text", "text": {"content": title}}]}
-                }
-            },
-        )
-
-    async def set_icon(
-        self, emoji: Optional[str] = None, external_url: Optional[str] = None
-    ) -> Optional[Dict[str, Any]]:
-        if emoji:
-            icon = {"type": "emoji", "emoji": emoji}
-        elif external_url:
-            icon = {"type": "external", "external": {"url": external_url}}
-        else:
-            return None
-
-        return await self._client.patch(f"pages/{self.page_id}", {"icon": icon})
-
+        
     async def set_cover(self, external_url: str) -> Optional[Dict[str, Any]]:
+        """Sets a cover image from an external URL.
+        """
+        
         return await self._client.patch(
             f"pages/{self.page_id}",
             {"cover": {"type": "external", "external": {"url": external_url}}},
         )
         
     async def set_random_gradient_cover(self) -> Optional[Dict[str, Any]]:
-        """
-        Sets a random gradient cover from Notion's default gradient covers.
-        
-        Returns:
-            Optional[Dict[str, Any]]: The API response or None if the operation fails
+        """ Sets a random gradient cover from Notion's default gradient covers.
         """
         default_notion_covers = [
             "https://www.notion.so/images/page-cover/gradients_8.png", 
@@ -56,3 +33,16 @@ class MetadataEditor(LoggingMixin):
         random_cover_url = random.choice(default_notion_covers)
         
         return await self.set_cover(random_cover_url)
+    
+    
+    async def get_cover_url(self) -> str:
+        """Retrieves the current cover image URL of the page.
+        """
+        
+        page_data = await self._client.get_page(self.page_id)
+        
+        if not page_data:
+            return ""
+        
+        return page_data.get("cover", {}).get("external", {}).get("url", "")
+