notionary 0.1.6__tar.gz → 0.1.7__tar.gz

{notionary-0.1.6 → notionary-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionary
-Version: 0.1.6
+Version: 0.1.7
 Summary: A toolkit to convert between Markdown and Notion blocks
 Home-page: https://github.com/mathisarends/notionary
 Author: Mathis Arends

notionary-0.1.7/notionary/core/database/notion_database_manager.py

@@ -0,0 +1,246 @@
+from typing import Any, AsyncGenerator, Dict, List, Optional
+
+from notionary.core.notion_client import NotionClient
+from notionary.core.page.notion_page_manager import NotionPageManager
+from notionary.util.logging_mixin import LoggingMixin
+from notionary.util.page_id_utils import format_uuid
+
+
+class NotionDatabaseManager(LoggingMixin):
+    """
+    Minimal manager for Notion databases.
+    Focused exclusively on creating basic pages and retrieving page managers 
+    for further page operations.
+    """
+
+    def __init__(self, database_id: str, token: Optional[str] = None):
+        """
+        Initialize the minimal database manager.
+
+        Args:
+            database_id: ID of the Notion database
+            token: Optional Notion API token
+        """
+        self.database_id = format_uuid(database_id) or database_id
+        self._client = NotionClient(token=token)
+
+
+    async def create_blank_page(self) -> Optional[str]:
+        """
+        Create a new blank page in the database with minimal properties.
+        
+        Returns:
+            Optional[str]: The ID of the created page, or None if creation failed
+        """
+        try:
+            response = await self._client.post(
+                "pages",
+                {
+                    "parent": {"database_id": self.database_id},
+                    "properties": {}  
+                }
+            )
+            
+            if response and "id" in response:
+                page_id = response["id"]
+                self.logger.info("Created blank page %s in database %s", page_id, self.database_id)
+                return page_id
+            
+            self.logger.warning("Page creation failed: invalid response")
+            return None
+                
+        except Exception as e:
+            self.logger.error("Error creating blank page: %s", str(e))
+            return None
+
+    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
+        """
+        self.logger.debug("Getting page manager for page %s", page_id)
+        
+        try:
+            # Check if the page exists
+            page_data = await self._client.get_page(page_id)
+            
+            if not page_data:
+                self.logger.error("Page %s not found", page_id)
+                return None
+                
+            return NotionPageManager(page_id=page_id)
+            
+        except Exception as e:
+            self.logger.error("Error getting page manager: %s", str(e))
+            return None
+
+    async def get_pages(
+        self,
+        limit: int = 100,
+        filter_conditions: Optional[Dict[str, Any]] = None,
+        sorts: Optional[List[Dict[str, Any]]] = None,
+    ) -> List[NotionPageManager]:
+        """
+        Get all pages from the database.
+
+        Args:
+            limit: Maximum number of pages to retrieve
+            filter_conditions: Optional filter to apply to the database query
+            sorts: Optional sort instructions for the database query
+
+        Returns:
+            List of NotionPageManager instances for each page
+        """
+        self.logger.debug(
+            "Getting up to %d pages with filter: %s, sorts: %s",
+            limit,
+            filter_conditions,
+            sorts,
+        )
+
+        pages: List[NotionPageManager] = []
+        count = 0
+
+        async for page in self.iter_pages(
+            page_size=min(limit, 100),
+            filter_conditions=filter_conditions,
+            sorts=sorts,
+        ):
+            pages.append(page)
+            count += 1
+
+            if count >= limit:
+                break
+
+        self.logger.debug(
+            "Retrieved %d pages from database %s", len(pages), self.database_id
+        )
+        return pages
+
+    async def iter_pages(
+        self,
+        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 the database.
+        Directly queries the Notion API without using the schema.
+
+        Args:
+            page_size: 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:
+            NotionPageManager instances for each page
+        """
+        self.logger.debug(
+            "Iterating pages with page_size: %d, filter: %s, sorts: %s",
+            page_size,
+            filter_conditions,
+            sorts,
+        )
+
+        start_cursor: Optional[str] = None
+        has_more = True
+
+        # Prepare the query body
+        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/{self.database_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
+
+            # Update pagination parameters
+            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 ""
+
+    async def delete_page(self, page_id: str) -> Dict[str, Any]:
+        """
+        Delete (archive) a page.
+
+        Args:
+            page_id: The ID of the page to delete
+
+        Returns:
+            Dict with success status, message, and page_id when successful
+        """
+        try:
+            formatted_page_id = format_uuid(page_id) or page_id
+            
+            # Archive the page (Notion's way of deleting)
+            data = {"archived": True}
+            
+            result = await self._client.patch(f"pages/{formatted_page_id}", data)
+            if not result:
+                self.logger.error("Error deleting page %s", formatted_page_id)
+                return {
+                    "success": False,
+                    "message": f"Failed to delete page {formatted_page_id}",
+                }
+            
+            self.logger.info("Page %s successfully deleted (archived)", formatted_page_id)
+            return {"success": True, "page_id": formatted_page_id}
+            
+        except Exception as e:
+            self.logger.error("Error in delete_page: %s", str(e))
+            return {"success": False, "message": f"Error: {str(e)}"}
+
+    async def close(self) -> None:
+        """Close the client connection."""
+        await self._client.close()

{notionary-0.1.6 → notionary-0.1.7}/notionary/core/database/notion_database_manager_factory.py

@@ -12,7 +12,7 @@ from notionary.exceptions.database_exceptions import (
     NotionDatabaseException,
 )
 from notionary.util.logging_mixin import LoggingMixin
-from notionary.util.uuid_utils import format_uuid
+from notionary.util.page_id_utils import format_uuid
 
 
 class NotionDatabaseFactory(LoggingMixin):
@@ -44,21 +44,11 @@ class NotionDatabaseFactory(LoggingMixin):
 
         try:
             formatted_id = format_uuid(database_id) or database_id
-
+            
             manager = NotionDatabaseManager(formatted_id, token)
+            
 
-            success = await manager.initialize()
-
-            if not success:
-                error_msg = (
-                    f"Failed to initialize database manager for ID: {formatted_id}"
-                )
-                logger.error(error_msg)
-                raise DatabaseInitializationError(formatted_id, error_msg)
-
-            logger.info(
-                lambda: f"Successfully created database manager for ID: {formatted_id}"
-            )
+            logger.info("Successfully created database manager for ID: %s", formatted_id)
             return manager
 
         except DatabaseInitializationError:
@@ -88,7 +78,7 @@ class NotionDatabaseFactory(LoggingMixin):
             An initialized NotionDatabaseManager instance
         """
         logger = cls.class_logger()
-        logger.debug(lambda: f"Searching for database with name: {database_name}")
+        logger.debug("Searching for database with name: %s", database_name)
 
         client = NotionClient(token=token)
 
@@ -116,11 +106,8 @@ class NotionDatabaseFactory(LoggingMixin):
                 logger.warning(error_msg)
                 raise DatabaseNotFoundException(database_name, error_msg)
 
-            logger.debug(
-                lambda: f"Found {len(databases)} databases, searching for best match"
-            )
+            logger.debug("Found %d databases, searching for best match", len(databases))
 
-            # Find best match using fuzzy matching
             best_match = None
             best_score = 0
 
@@ -135,7 +122,6 @@ class NotionDatabaseFactory(LoggingMixin):
                     best_score = score
                     best_match = db
 
-            # Use a minimum threshold for match quality (0.6 = 60% similarity)
             if best_score < 0.6 or not best_match:
                 error_msg = f"No good database name match found for '{database_name}'. Best match had score {best_score:.2f}"
                 logger.warning(error_msg)
@@ -150,23 +136,11 @@ class NotionDatabaseFactory(LoggingMixin):
 
             matched_name = cls._extract_title_from_database(best_match)
 
-            logger.info(
-                lambda: f"Found matching database: '{matched_name}' (ID: {database_id}) with score: {best_score:.2f}"
-            )
+            logger.info("Found matching database: '%s' (ID: %s) with score: %.2f", matched_name, database_id, best_score)
 
             manager = NotionDatabaseManager(database_id, token)
-            success = await manager.initialize()
 
-            if not success:
-                error_msg = (
-                    f"Failed to initialize database manager for database {database_id}"
-                )
-                logger.error(error_msg)
-                raise DatabaseInitializationError(database_id, error_msg)
-
-            logger.info(
-                lambda: f"Successfully created database manager for '{matched_name}'"
-            )
+            logger.info(f"Successfully created database manager for '{matched_name}'")
             await client.close()
             return manager
 
@@ -183,22 +157,11 @@ class NotionDatabaseFactory(LoggingMixin):
     def _extract_title_from_database(cls, database: Dict[str, Any]) -> str:
         """
         Extract the title from a database object.
-
-        Args:
-            database: A database object from the Notion API
-
-        Returns:
-            The extracted title or "Untitled" if no title is found
-
-        Raises:
-            DatabaseParsingError: If there's an error parsing the database title
         """
         try:
-            # Check for title in the root object
             if "title" in database:
                 return cls._extract_text_from_rich_text(database["title"])
 
-            # Check for title in properties
             if "properties" in database and "title" in database["properties"]:
                 title_prop = database["properties"]["title"]
                 if "title" in title_prop:
@@ -215,12 +178,6 @@ class NotionDatabaseFactory(LoggingMixin):
     def _extract_text_from_rich_text(cls, rich_text: List[Dict[str, Any]]) -> str:
         """
         Extract plain text from a rich text array.
-
-        Args:
-            rich_text: A list of rich text objects from Notion API
-
-        Returns:
-            The concatenated plain text content
         """
         if not rich_text:
             return ""
@@ -230,4 +187,4 @@ class NotionDatabaseFactory(LoggingMixin):
             if "plain_text" in text_obj:
                 text_parts.append(text_obj["plain_text"])
 
-        return "".join(text_parts)
+        return "".join(text_parts)

notionary-0.1.7/notionary/core/database/notion_database_schema.py

@@ -0,0 +1,104 @@
+from typing import (
+    AsyncGenerator,
+    Dict,
+    Optional,
+    Any,
+)
+from notionary.core.notion_client import NotionClient
+from notionary.util.logging_mixin import LoggingMixin
+
+class NotionDatabaseAccessor(LoggingMixin):
+    """
+    A utility class that provides methods to access Notion databases.
+    Focused on efficient, paginated access to databases without unnecessary complexity.
+    """
+
+    def __init__(self, client: Optional[NotionClient] = None) -> None:
+        """
+        Initialize the accessor with a NotionClient.
+
+        Args:
+            client: NotionClient instance for API communication
+        """
+        self._client = client if client else NotionClient()
+        self.logger.info("NotionDatabaseAccessor initialized")
+
+    async def iter_databases(
+        self, page_size: int = 100
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        Asynchronous generator that yields Notion databases one by one.
+
+        Uses the Notion API to provide paginated access to all databases
+        without loading all of them into memory at once.
+
+        Args:
+            page_size: The number of databases to fetch per request
+
+        Yields:
+            Individual database objects from the Notion API
+        """
+        start_cursor: Optional[str] = None
+
+        while True:
+            body: Dict[str, Any] = {
+                "filter": {"value": "database", "property": "object"},
+                "page_size": page_size,
+            }
+
+            if start_cursor:
+                body["start_cursor"] = start_cursor
+
+            result = await self._client.post("search", data=body)
+
+            if not result or "results" not in result:
+                self.logger.error("Error fetching databases")
+                break
+
+            for database in result["results"]:
+                yield database
+
+            if "has_more" in result and result["has_more"] and "next_cursor" in result:
+                start_cursor = result["next_cursor"]
+            else:
+                break
+
+    async def get_database(self, database_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get the details for a specific database.
+
+        Args:
+            database_id: The ID of the database
+
+        Returns:
+            Database details or None if not found
+        """
+        db_details = await self._client.get(f"databases/{database_id}")
+        if not db_details:
+            self.logger.error("Failed to retrieve database %s", database_id)
+            return None
+
+        return db_details
+
+    def extract_database_title(self, database: Dict[str, Any]) -> str:
+        """
+        Extract the database title from a Notion API response.
+
+        Args:
+            database: The database object from the Notion API
+
+        Returns:
+            The extracted title or "Untitled" if no title is found
+        """
+        title = "Untitled"
+
+        if "title" in database:
+            title_parts = []
+            for text_obj in database["title"]:
+                if "plain_text" in text_obj:
+                    title_parts.append(text_obj["plain_text"])
+
+            if title_parts:
+                title = "".join(title_parts)
+
+        return title

{notionary-0.1.6 → notionary-0.1.7}/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-0.1.6/notionary/core/page → notionary-0.1.7/notionary/core/page/content}/page_content_manager.py

@@ -54,7 +54,6 @@ class PageContentManager(LoggingMixin):
 
         return f"Deleted {deleted}/{len(results)} 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:

notionary-0.1.7/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-0.1.7/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  
+    
+