notionary 0.1.29__py3-none-any.whl → 0.2.1__py3-none-any.whl

notionary/models/notion_page_response.py

@@ -0,0 +1,100 @@
+from dataclasses import dataclass
+from typing import Literal, Optional, Dict, Any, Union
+
+from pydantic import BaseModel
+
+
+@dataclass
+class User:
+    """Represents a Notion user object."""
+
+    object: str
+    id: str
+
+
+@dataclass
+class ExternalFile:
+    """Represents an external file, e.g., for cover images."""
+
+    url: str
+
+
+@dataclass
+class Cover:
+    """Cover image for a Notion page."""
+
+    type: str
+    external: ExternalFile
+
+
+@dataclass
+class EmojiIcon:
+    type: Literal["emoji"]
+    emoji: str
+
+
+@dataclass
+class ExternalIcon:
+    type: Literal["external"]
+    external: ExternalFile
+
+
+@dataclass
+class FileObject:
+    url: str
+    expiry_time: str
+
+
+@dataclass
+class FileIcon:
+    type: Literal["file"]
+    file: FileObject
+
+
+Icon = Union[EmojiIcon, ExternalIcon, FileIcon]
+
+
+@dataclass
+class DatabaseParent:
+    type: Literal["database_id"]
+    database_id: str
+
+
+@dataclass
+class PageParent:
+    type: Literal["page_id"]
+    page_id: str
+
+
+@dataclass
+class WorkspaceParent:
+    type: Literal["workspace"]
+    workspace: bool = True
+
+
+Parent = Union[DatabaseParent, PageParent, WorkspaceParent]
+
+
+@dataclass
+class NotionPageResponse(BaseModel):
+    """
+    Represents a full Notion page object as returned by the Notion API.
+
+    This structure is flexible and designed to work with different database schemas.
+    """
+
+    object: str
+    id: str
+    created_time: str
+    last_edited_time: str
+    created_by: User
+    last_edited_by: User
+    cover: Optional[Cover]
+    icon: Optional[Icon]
+    parent: Parent
+    archived: bool
+    in_trash: bool
+    properties: Dict[str, Any]
+    url: str
+    public_url: Optional[str]
+    request_id: str

notionary/notion_client.py

@@ -5,6 +5,8 @@ from enum import Enum
 from typing import Dict, Any, Optional, Union
 import httpx
 from dotenv import load_dotenv
+from notionary.models.notion_database_response import NotionDatabaserResponse
+from notionary.models.notion_page_response import NotionPageResponse
 from notionary.util.logging_mixin import LoggingMixin
 
 
@@ -54,6 +56,7 @@ class NotionClient(LoggingMixin):
             await self.client.aclose()
             self.client = None
 
+    # Das hier für die unterschiedlichen responses hier noch richtig typne wäre gut.
     async def get(self, endpoint: str) -> Optional[Dict[str, Any]]:
         """
         Sends a GET request to the specified Notion API endpoint.
@@ -66,17 +69,33 @@ class NotionClient(LoggingMixin):
         """
         return await self._make_request(HttpMethod.GET, endpoint)
 
-    async def get_page(self, page_id: str) -> Optional[Dict[str, Any]]:
+    # TODO: Get Blocks implementeren und Patch Blcoks hierfür das Typing finden:
+
+    async def get_database(self, database_id: str) -> NotionDatabaserResponse:
+        """
+        Ruft die Metadaten einer Notion-Datenbank anhand ihrer ID ab und gibt sie als NotionPageResponse zurück.
+
+        Args:
+            database_id: Die Notion-Datenbank-ID.
+
+        Returns:
+            Ein NotionPageResponse-Objekt mit den Datenbankmetadaten.
+        """
+        return NotionDatabaserResponse.model_validate(
+            await self.get(f"databases/{database_id}")
+        )
+
+    async def get_page(self, page_id: str) -> NotionPageResponse:
         """
-        Fetches metadata for a Notion page by its ID.
+        Ruft die Metadaten einer Notion-Seite anhand ihrer ID ab und gibt sie als NotionPageResponse zurück.
 
         Args:
-            page_id: The Notion page ID.
+            page_id: Die Notion-Seiten-ID.
 
         Returns:
-            A dictionary with the page data, or None if the request failed.
+            Ein NotionPageResponse-Objekt mit den Seitenmetadaten.
         """
-        return await self.get(f"pages/{page_id}")
+        return NotionPageResponse.model_validate(await self.get(f"pages/{page_id}"))
 
     async def post(
         self, endpoint: str, data: Optional[Dict[str, Any]] = None
@@ -108,6 +127,20 @@ class NotionClient(LoggingMixin):
         """
         return await self._make_request(HttpMethod.PATCH, endpoint, data)
 
+    async def patch_page(
+        self, page_id: str, data: Optional[Dict[str, Any]] = None
+    ) -> NotionPageResponse:
+        """
+        Sends a PATCH request to update a Notion page.
+
+        Args:
+            page_id: The ID of the page to update.
+            data: Optional dictionary payload to send with the request.
+        """
+        return NotionPageResponse.model_validate(
+            await self.patch(f"pages/{page_id}", data=data)
+        )
+
     async def delete(self, endpoint: str) -> bool:
         """
         Sends a DELETE request to the specified Notion API endpoint.

notionary/page/content/page_content_retriever.py

@@ -0,0 +1,68 @@
+import json
+from typing import Any, Dict, List, Optional
+
+from notionary.elements.registry.block_registry import BlockRegistry
+from notionary.notion_client import NotionClient
+
+from notionary.page.notion_to_markdown_converter import (
+    NotionToMarkdownConverter,
+)
+from notionary.util.logging_mixin import LoggingMixin
+
+
+class PageContentRetriever(LoggingMixin):
+    def __init__(
+        self,
+        page_id: str,
+        client: NotionClient,
+        block_registry: BlockRegistry,
+    ):
+        self.page_id = page_id
+        self._client = client
+        self._notion_to_markdown_converter = NotionToMarkdownConverter(
+            block_registry=block_registry
+        )
+
+    async def get_page_content(self) -> str:
+        blocks = await self._get_page_blocks_with_children()
+        return self._notion_to_markdown_converter.convert(blocks)
+
+    async def _get_page_blocks_with_children(
+        self, parent_id: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        blocks = (
+            await self._get_blocks()
+            if parent_id is None
+            else await self._get_block_children(parent_id)
+        )
+
+        if not blocks:
+            return []
+
+        for block in blocks:
+            if not block.get("has_children"):
+                continue
+
+            block_id = block.get("id")
+            if not block_id:
+                continue
+
+            children = await self._get_page_blocks_with_children(block_id)
+            if children:
+                block["children"] = children
+
+        return blocks
+
+    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.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.get("results", [])

notionary/page/content/page_content_writer.py

@@ -0,0 +1,103 @@
+from typing import Any, Dict
+
+from notionary.elements.divider_element import DividerElement
+from notionary.elements.registry.block_registry import BlockRegistry
+from notionary.notion_client import NotionClient
+
+from notionary.page.markdown_to_notion_converter import (
+    MarkdownToNotionConverter,
+)
+from notionary.page.notion_to_markdown_converter import (
+    NotionToMarkdownConverter,
+)
+from notionary.page.content.notion_page_content_chunker import (
+    NotionPageContentChunker,
+)
+from notionary.util.logging_mixin import LoggingMixin
+
+
+class PageContentWriter(LoggingMixin):
+    def __init__(
+        self,
+        page_id: str,
+        client: NotionClient,
+        block_registry: BlockRegistry,
+    ):
+        self.page_id = page_id
+        self._client = client
+        self.block_registry = block_registry
+        self._markdown_to_notion_converter = MarkdownToNotionConverter(
+            block_registry=block_registry
+        )
+        self._notion_to_markdown_converter = NotionToMarkdownConverter(
+            block_registry=block_registry
+        )
+        self._chunker = NotionPageContentChunker()
+
+    async def append_markdown(self, markdown_text: str, append_divider=False) -> bool:
+        """
+        Append markdown text to a Notion page, automatically handling content length limits.
+
+        """
+        if append_divider and not self.block_registry.contains(DividerElement):
+            self.logger.warning(
+                "DividerElement not registered. Appending divider skipped."
+            )
+            append_divider = False
+
+        # Append divider in markdonw format as it will be converted to a Notion divider block
+        if append_divider:
+            markdown_text = markdown_text + "\n\n---\n\n"
+
+        try:
+            blocks = self._markdown_to_notion_converter.convert(markdown_text)
+            fixed_blocks = self._chunker.fix_blocks_content_length(blocks)
+
+            result = await self._client.patch(
+                f"blocks/{self.page_id}/children", {"children": fixed_blocks}
+            )
+            return bool(result)
+        except Exception as e:
+            self.logger.error("Error appending markdown: %s", str(e))
+            return False
+
+    async def clear_page_content(self) -> bool:
+        """
+        Clear all content of the page.
+        """
+        try:
+            blocks_resp = await self._client.get(f"blocks/{self.page_id}/children")
+            results = blocks_resp.get("results", []) if blocks_resp else []
+
+            if not results:
+                return True
+
+            success = True
+            for block in results:
+                block_success = await self._delete_block_with_children(block)
+                if not block_success:
+                    success = False
+
+            return success
+        except Exception as e:
+            self.logger.error("Error clearing page content: %s", str(e))
+            return False
+
+    async def _delete_block_with_children(self, block: Dict[str, Any]) -> bool:
+        """
+        Delete a block and all its children.
+        """
+        try:
+            if block.get("has_children", False):
+                children_resp = await self._client.get(f"blocks/{block['id']}/children")
+                child_results = children_resp.get("results", [])
+
+                for child in child_results:
+                    child_success = await self._delete_block_with_children(child)
+                    if not child_success:
+                        return False
+
+            return await self._client.delete(f"blocks/{block['id']}")
+        except Exception as e:
+            self.logger.error("Failed to delete block: %s", str(e))
+            return False

notionary/page/markdown_to_notion_converter.py

@@ -1,8 +1,8 @@
 from typing import Dict, Any, List, Optional, Tuple
 
-from notionary.elements.registry.block_element_registry import BlockElementRegistry
-from notionary.elements.registry.block_element_registry_builder import (
-    BlockElementRegistryBuilder,
+from notionary.elements.registry.block_registry import BlockRegistry
+from notionary.elements.registry.block_registry_builder import (
+    BlockRegistryBuilder,
 )
 
 
@@ -13,10 +13,10 @@ class MarkdownToNotionConverter:
     TOGGLE_ELEMENT_TYPES = ["ToggleElement", "ToggleableHeadingElement"]
     PIPE_CONTENT_PATTERN = r"^\|\s?(.*)$"
 
-    def __init__(self, block_registry: Optional[BlockElementRegistry] = None):
+    def __init__(self, block_registry: Optional[BlockRegistry] = None):
         """Initialize the converter with an optional custom block registry."""
         self._block_registry = (
-            block_registry or BlockElementRegistryBuilder().create_full_registry()
+            block_registry or BlockRegistryBuilder().create_full_registry()
         )
 
     def convert(self, markdown_text: str) -> List[Dict[str, Any]]:

notionary/page/metadata/metadata_editor.py

@@ -5,24 +5,75 @@ from notionary.util.logging_mixin import LoggingMixin
 
 
 class MetadataEditor(LoggingMixin):
+    """
+    Manages and edits the metadata and properties of a Notion page.
+    """
+
     def __init__(self, page_id: str, client: NotionClient):
+        """
+        Initialize the metadata editor.
+
+        Args:
+            page_id: The ID of the Notion page
+            client: The Notion API client
+        """
         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}",
-            {
+    async def set_title(self, title: str) -> Optional[str]:
+        """
+        Sets the title of the page.
+
+        Args:
+            title: The new title for the page.
+
+        Returns:
+            Optional[str]: The new title if successful, None otherwise.
+        """
+        try:
+            data = {
                 "properties": {
                     "title": {"title": [{"type": "text", "text": {"content": title}}]}
                 }
-            },
-        )
+            }
+
+            result = await self._client.patch_page(self.page_id, data)
+
+            if result:
+                return title
+            return None
+        except Exception as e:
+            self.logger.error("Error setting page title: %s", str(e))
+            return None
+
+    async def set_property_by_name(
+        self, property_name: str, value: Any
+    ) -> Optional[str]:
+        """
+        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[str]: The property name if successful, None if 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)
 
-    async def set_property(
+    async def _set_property(
         self, property_name: str, property_value: Any, property_type: str
-    ) -> Optional[Dict[str, Any]]:
+    ) -> Optional[str]:
         """
         Generic method to set any property on a Notion page.
 
@@ -32,7 +83,7 @@ class MetadataEditor(LoggingMixin):
             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
+            Optional[str]: The property name if successful, None if operation fails
         """
         property_payload = self._property_formatter.format_value(
             property_type, property_value
@@ -44,12 +95,19 @@ class MetadataEditor(LoggingMixin):
             )
             return None
 
-        return await self._client.patch(
-            f"pages/{self.page_id}",
-            {"properties": {property_name: property_payload}},
-        )
+        try:
+            result = await self._client.patch_page(
+                self.page_id, {"properties": {property_name: property_payload}}
+            )
+
+            if result:
+                return property_name
+            return None
+        except Exception as e:
+            self.logger.error("Error setting property '%s': %s", property_name, str(e))
+            return None
 
-    async def get_property_schema(self) -> Dict[str, Dict[str, Any]]:
+    async def _get_property_schema(self) -> Dict[str, Dict[str, Any]]:
         """
         Retrieves the schema for all properties of the page.
 
@@ -59,64 +117,34 @@ class MetadataEditor(LoggingMixin):
         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
+        # Property types that can have options
+        option_types = {
+            "select": "select",
+            "multi_select": "multi_select",
+            "status": "status",
+        }
 
-        for prop_name, prop_data in page_data["properties"].items():
+        for prop_name, prop_data in page_data.properties.items():
             prop_type = prop_data.get("type")
-            property_schema[prop_name] = {
+
+            schema_entry = {
                 "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:
+            # Check if this property type can have options
+            if prop_type in option_types:
+                option_key = option_types[prop_type]
+                try:
+                    prop_type_data = prop_data.get(option_key, {})
+                    if isinstance(prop_type_data, dict):
+                        schema_entry["options"] = prop_type_data.get("options", [])
+                except Exception as e:
                     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_schema[prop_name] = schema_entry
 
-        property_type = property_schema[property_name]["type"]
-        return await self.set_property(property_name, value, property_type)
+        return property_schema

notionary/page/metadata/notion_icon_manager.py

@@ -1,5 +1,7 @@
-from typing import Any, Dict, Optional
+import json
+from typing import Optional
 
+from notionary.models.notion_page_response import EmojiIcon, ExternalIcon, FileIcon
 from notionary.notion_client import NotionClient
 from notionary.util.logging_mixin import LoggingMixin
 
@@ -9,42 +11,67 @@ class NotionPageIconManager(LoggingMixin):
         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
+    async def set_emoji_icon(self, emoji: str) -> Optional[str]:
+        """
+        Sets the page icon to an emoji.
 
-        return await self._client.patch(f"pages/{self.page_id}", {"icon": icon})
+        Args:
+            emoji (str): The emoji character to set as the icon.
 
-    async def get_icon(self) -> Optional[str]:
+        Returns:
+            Optional[str]: The emoji that was set as the icon, or None if the operation failed.
         """
-        Retrieves the page icon - either emoji or external URL.
+        icon = {"type": "emoji", "emoji": emoji}
+        page_response = await self._client.patch_page(
+            page_id=self.page_id, data={"icon": icon}
+        )
+
+        if page_response and page_response.icon and page_response.icon.type == "emoji":
+            return page_response.icon.emoji
+        return None
+
+    async def set_external_icon(self, external_icon_url: str) -> Optional[str]:
+        """
+        Sets the page icon to an external image.
+
+        Args:
+            url (str): The URL of the external image to set as the icon.
 
         Returns:
-            Optional[str]: Emoji character or URL if set, None if no icon
+            Optional[str]: The URL of the external image that was set as the icon,
+                        or None if the operation failed.
         """
-        page_data = await self._client.get_page(self.page_id)
+        icon = {"type": "external", "external": {"url": external_icon_url}}
+        page_response = await self._client.patch_page(
+            page_id=self.page_id, data={"icon": icon}
+        )
 
-        if not page_data:
-            return ""
+        if (
+            page_response
+            and page_response.icon
+            and page_response.icon.type == "external"
+        ):
+            return page_response.icon.external.url
+        return None
 
-        # Get icon data, default to empty dict if not present or None
-        icon_data = page_data.get("icon")
+    async def get_icon(self) -> Optional[str]:
+        """
+        Retrieves the page icon - either emoji or external URL.
 
-        # If icon is None or not present, return None
-        if not icon_data:
-            return ""
+        Returns:
+            Optional[str]: Emoji character or URL if set, None if no icon.
+        """
+        page_response = await self._client.get_page(self.page_id)
+        if not page_response or not page_response.icon:
+            return None
 
-        icon_type = icon_data.get("type")
+        icon = page_response.icon
 
-        if icon_type == "emoji":
-            return icon_data.get("emoji")
-        if icon_type == "external":
-            return icon_data.get("external", {}).get("url")
+        if isinstance(icon, EmojiIcon):
+            return icon.emoji
+        if isinstance(icon, ExternalIcon):
+            return icon.external.url
+        if isinstance(icon, FileIcon):
+            return icon.file.url
 
-        return ""
+        return None