notionary 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

notionary/core/database/database_discovery.py

@@ -0,0 +1,140 @@
+from typing import (
+    AsyncGenerator,
+    Dict,
+    List,
+    Optional,
+    Any,
+    Tuple,
+)
+from notionary.core.notion_client import NotionClient
+from notionary.util.logging_mixin import LoggingMixin
+
+
+class DatabaseDiscovery(LoggingMixin):
+    """
+    A utility class that discovers Notion databases accessible to your integration.
+    Focused on efficiently retrieving essential database information.
+    """
+
+    def __init__(self, client: Optional[NotionClient] = None) -> None:
+        """
+        Initialize the database discovery with a NotionClient.
+
+        Args:
+            client: NotionClient instance for API communication
+        """
+        self._client = client if client else NotionClient()
+        self.logger.info("DatabaseDiscovery initialized")
+
+    async def discover(self, page_size: int = 100) -> List[Tuple[str, str]]:
+        """
+        Discover all accessible databases and return their titles and IDs.
+
+        Args:
+            page_size: The number of databases to fetch per request
+
+        Returns:
+            List of tuples containing (database_title, database_id)
+        """
+        databases = []
+        
+        async for database in self._iter_databases(page_size):
+            db_id = database.get("id")
+            if not db_id:
+                continue
+                
+            title = self._extract_database_title(database)
+            databases.append((title, db_id))
+            
+        return databases
+        
+    async def discover_and_print(self, page_size: int = 100) -> List[Tuple[str, str]]:
+        """
+        Discover databases and print the results in a nicely formatted way.
+        
+        This is a convenience method that discovers databases and handles
+        the formatting and printing of results.
+        
+        Args:
+            page_size: The number of databases to fetch per request
+            
+        Returns:
+            The same list of databases as discover() for further processing
+        """
+        databases = await self.discover(page_size)
+        
+        if not databases:
+            print("\n⚠️ No databases found!")
+            print("Please ensure your Notion integration has access to databases.")
+            print("You need to share the databases with your integration in Notion settings.")
+            return databases
+            
+        print(f"✅ Found {len(databases)} databases:")
+        
+        for i, (title, db_id) in enumerate(databases, 1):
+            print(f"{i}. {title} (ID: {db_id})")
+        
+        return databases
+
+    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")
+                return
+
+            for database in result["results"]:
+                yield database
+
+            if not result.get("has_more") or not result.get("next_cursor"):
+                return
+                
+            start_cursor = result["next_cursor"]
+
+    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
+        """
+        if "title" not in database:
+            return "Untitled"
+            
+        title_parts = []
+        for text_obj in database["title"]:
+            if "plain_text" in text_obj:
+                title_parts.append(text_obj["plain_text"])
+
+        if not title_parts:
+            return "Untitled"
+            
+        return "".join(title_parts)

notionary/core/database/notion_database_manager.py

@@ -9,7 +9,7 @@ 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 
+    Focused exclusively on creating basic pages and retrieving page managers
     for further page operations.
     """
 
@@ -24,61 +24,33 @@ class NotionDatabaseManager(LoggingMixin):
         self.database_id = format_uuid(database_id) or database_id
         self._client = NotionClient(token=token)
 
-
-    async def create_blank_page(self) -> Optional[str]:
+    async def create_blank_page(self) -> Optional[NotionPageManager]:
         """
         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
+            NotionPageManager for the created page, or None if creation failed
         """
         try:
             response = await self._client.post(
-                "pages",
-                {
-                    "parent": {"database_id": self.database_id},
-                    "properties": {}  
-                }
+                "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.info(
+                    "Created blank page %s in database %s", page_id, self.database_id
+                )
+
+                return NotionPageManager(page_id=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,
@@ -174,10 +146,12 @@ class NotionDatabaseManager(LoggingMixin):
             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)
+                notion_page_manager = NotionPageManager(
+                    page_id=page_id, title=title, url=page_url
+                )
                 yield notion_page_manager
 
             # Update pagination parameters
@@ -222,10 +196,10 @@ class NotionDatabaseManager(LoggingMixin):
         """
         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)
@@ -233,14 +207,17 @@ class NotionDatabaseManager(LoggingMixin):
                     "success": False,
                     "message": f"Failed to delete page {formatted_page_id}",
                 }
-            
-            self.logger.info("Page %s successfully deleted (archived)", 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()
+        await self._client.close()
+

notionary/core/database/notion_database_manager_factory.py

@@ -44,11 +44,12 @@ class NotionDatabaseFactory(LoggingMixin):
 
         try:
             formatted_id = format_uuid(database_id) or database_id
-            
+
             manager = NotionDatabaseManager(formatted_id, token)
-            
 
-            logger.info("Successfully created database manager for ID: %s", formatted_id)
+            logger.info(
+                "Successfully created database manager for ID: %s", formatted_id
+            )
             return manager
 
         except DatabaseInitializationError:
@@ -136,7 +137,12 @@ class NotionDatabaseFactory(LoggingMixin):
 
             matched_name = cls._extract_title_from_database(best_match)
 
-            logger.info("Found matching database: '%s' (ID: %s) with score: %.2f", matched_name, database_id, best_score)
+            logger.info(
+                "Found matching database: '%s' (ID: %s) with score: %.2f",
+                matched_name,
+                database_id,
+                best_score,
+            )
 
             manager = NotionDatabaseManager(database_id, token)
 

notionary/core/notion_client.py

@@ -7,6 +7,7 @@ import httpx
 from dotenv import load_dotenv
 from notionary.util.logging_mixin import LoggingMixin
 
+
 class HttpMethod(Enum):
     """Enum für HTTP-Methoden."""
 
@@ -15,6 +16,7 @@ class HttpMethod(Enum):
     PATCH = "patch"
     DELETE = "delete"
 
+
 class NotionClient(LoggingMixin):
     """Verbesserter Notion-Client mit automatischer Ressourcenverwaltung."""
 
@@ -50,7 +52,7 @@ class NotionClient(LoggingMixin):
 
     async def get(self, endpoint: str) -> Optional[Dict[str, Any]]:
         return await self._make_request(HttpMethod.GET, endpoint)
-    
+
     async def get_page(self, page_id: str) -> Optional[Dict[str, Any]]:
         return await self.get(f"pages/{page_id}")
 
@@ -126,4 +128,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/content/notion_page_content_chunker.py

@@ -0,0 +1,84 @@
+import re
+from typing import Any, Dict, List
+from notionary.util.logging_mixin import LoggingMixin
+
+
+class NotionPageContentChunker(LoggingMixin):
+    """
+    Handles markdown text processing to comply with Notion API length limitations.
+
+    This class specifically addresses the Notion API constraint that limits
+    rich_text elements to a maximum of 2000 characters. This particularly affects
+    paragraph blocks within toggle blocks or other nested structures.
+
+    Resolves the following typical API error:
+    "validation_error - body.children[79].toggle.children[2].paragraph.rich_text[0].text.content.length
+    should be ≤ 2000, instead was 2162."
+
+    The class provides methods for:
+    1. Automatically truncating text that exceeds the limit
+    2. Splitting markdown into smaller units for separate API requests
+    """
+
+    def __init__(self, max_text_length: int = 1900):
+        self.max_text_length = max_text_length
+
+    def fix_blocks_content_length(
+        self, blocks: List[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
+        """Check each block and ensure text content doesn't exceed Notion's limit."""
+        return [self._fix_single_block_content(block) for block in blocks]
+
+    def _fix_single_block_content(self, block: Dict[str, Any]) -> Dict[str, Any]:
+        """Fix content length in a single block and its children recursively."""
+        block_copy = block.copy()
+
+        block_type = block.get("type")
+        if not block_type:
+            return block_copy
+
+        content = block.get(block_type)
+        if not content:
+            return block_copy
+
+        if "rich_text" in content:
+            self._fix_rich_text_content(block_copy, block_type, content)
+
+        if "children" in content and content["children"]:
+            block_copy[block_type]["children"] = [
+                self._fix_single_block_content(child) for child in content["children"]
+            ]
+
+        return block_copy
+
+    def _fix_rich_text_content(
+        self, block_copy: Dict[str, Any], block_type: str, content: Dict[str, Any]
+    ) -> None:
+        """Fix rich text content that exceeds the length limit."""
+        rich_text = content["rich_text"]
+        for i, text_item in enumerate(rich_text):
+            if "text" not in text_item or "content" not in text_item["text"]:
+                continue
+
+            text_content = text_item["text"]["content"]
+            if len(text_content) <= self.max_text_length:
+                continue
+
+            self.logger.warning(
+                "Truncating text content from %d to %d chars",
+                len(text_content),
+                self.max_text_length,
+            )
+            block_copy[block_type]["rich_text"][i]["text"]["content"] = text_content[
+                : self.max_text_length
+            ]
+
+    def split_to_paragraphs(self, markdown_text: str) -> List[str]:
+        """Split markdown into paragraphs."""
+        paragraphs = re.split(r"\n\s*\n", markdown_text)
+        return [p for p in paragraphs if p.strip()]
+
+    def split_to_sentences(self, paragraph: str) -> List[str]:
+        """Split a paragraph into sentences."""
+        sentences = re.split(r"(?<=[.!?])\s+", paragraph)
+        return [s for s in sentences if s.strip()]

notionary/core/page/content/page_content_manager.py

@@ -1,3 +1,4 @@
+import re
 from typing import Any, Dict, List, Optional
 
 from notionary.core.converters.markdown_to_notion_converter import (
@@ -10,6 +11,9 @@ from notionary.core.converters.registry.block_element_registry import (
     BlockElementRegistry,
 )
 from notionary.core.notion_client import NotionClient
+from notionary.core.page.content.notion_page_content_chunker import (
+    NotionPageContentChunker,
+)
 from notionary.util.logging_mixin import LoggingMixin
 
 
@@ -28,15 +32,29 @@ class PageContentManager(LoggingMixin):
         self._notion_to_markdown_converter = NotionToMarkdownConverter(
             block_registry=block_registry
         )
+        self._chunker = NotionPageContentChunker()
 
     async def append_markdown(self, markdown_text: str) -> str:
-        blocks = self._markdown_to_notion_converter.convert(markdown_text)
-        result = await self._client.patch(
-            f"blocks/{self.page_id}/children", {"children": blocks}
-        )
-        return (
-            "Successfully added text to the page." if result else "Failed to add text."
-        )
+        """
+        Append markdown text to a Notion page, automatically handling content length limits.
+        """
+        try:
+            blocks = self._markdown_to_notion_converter.convert(markdown_text)
+
+            # Fix any blocks that exceed Notion's content length limits
+            fixed_blocks = self._chunker.fix_blocks_content_length(blocks)
+
+            result = await self._client.patch(
+                f"blocks/{self.page_id}/children", {"children": fixed_blocks}
+            )
+            return (
+                "Successfully added text to the page."
+                if result
+                else "Failed to add text."
+            )
+        except Exception as e:
+            self.logger.error("Error appending markdown: %s", str(e))
+            raise
 
     async def clear(self) -> str:
         blocks = await self._client.get(f"blocks/{self.page_id}/children")
@@ -53,7 +71,7 @@ class PageContentManager(LoggingMixin):
             if block.get("type") in ["child_database", "database", "linked_database"]:
                 skipped += 1
                 continue
-                
+
             if await self._client.delete(f"blocks/{block['id']}"):
                 deleted += 1
 

notionary/core/page/metadata/metadata_editor.py

@@ -20,90 +20,103 @@ class MetadataEditor(LoggingMixin):
             },
         )
 
-    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 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
+                "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", [])
+                        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", [])
+                        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", [])
+                        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)
-                
+                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]]:
+
+    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)
+            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)
+        return await self.set_property(property_name, value, property_type)

notionary/core/page/metadata/notion_icon_manager.py

@@ -3,11 +3,12 @@ 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]]:
@@ -19,28 +20,25 @@ class NotionPageIconManager(LoggingMixin):
             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  
-    
-    
+
+        return None