notionary 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

notionary/{core/converters → converters}/registry/block_element_registry_builder.py

@@ -1,30 +1,30 @@
 from typing import List, Type
 from collections import OrderedDict
 
-from notionary.core.converters.elements.audio_element import AudioElement
-from notionary.core.converters.elements.embed_element import EmbedElement
-from notionary.core.converters.elements.notion_block_element import NotionBlockElement
-from notionary.core.converters.registry.block_element_registry import (
+from notionary.converters.elements.audio_element import AudioElement
+from notionary.converters.elements.embed_element import EmbedElement
+from notionary.converters.elements.notion_block_element import NotionBlockElement
+from notionary.converters.registry.block_element_registry import (
     BlockElementRegistry,
 )
 
-from notionary.core.converters.elements.paragraph_element import ParagraphElement
-from notionary.core.converters.elements.heading_element import HeadingElement
-from notionary.core.converters.elements.callout_element import CalloutElement
-from notionary.core.converters.elements.code_block_element import CodeBlockElement
-from notionary.core.converters.elements.divider_element import DividerElement
-from notionary.core.converters.elements.table_element import TableElement
-from notionary.core.converters.elements.todo_lists import TodoElement
-from notionary.core.converters.elements.list_element import (
+from notionary.converters.elements.paragraph_element import ParagraphElement
+from notionary.converters.elements.heading_element import HeadingElement
+from notionary.converters.elements.callout_element import CalloutElement
+from notionary.converters.elements.code_block_element import CodeBlockElement
+from notionary.converters.elements.divider_element import DividerElement
+from notionary.converters.elements.table_element import TableElement
+from notionary.converters.elements.todo_lists import TodoElement
+from notionary.converters.elements.list_element import (
     BulletedListElement,
     NumberedListElement,
 )
-from notionary.core.converters.elements.qoute_element import QuoteElement
-from notionary.core.converters.elements.image_element import ImageElement
-from notionary.core.converters.elements.video_element import VideoElement
-from notionary.core.converters.elements.toggle_element import ToggleElement
-from notionary.core.converters.elements.bookmark_element import BookmarkElement
-from notionary.core.converters.elements.column_element import ColumnElement
+from notionary.converters.elements.qoute_element import QuoteElement
+from notionary.converters.elements.image_element import ImageElement
+from notionary.converters.elements.video_element import VideoElement
+from notionary.converters.elements.toggle_element import ToggleElement
+from notionary.converters.elements.bookmark_element import BookmarkElement
+from notionary.converters.elements.column_element import ColumnElement
 
 
 class BlockElementRegistryBuilder:

notionary/database/database_discovery.py

@@ -0,0 +1,142 @@
+from typing import (
+    AsyncGenerator,
+    Dict,
+    List,
+    Optional,
+    Any,
+    Tuple,
+)
+from notionary.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 → database}/database_info_service.py

@@ -1,5 +1,5 @@
 from typing import Optional
-from notionary.core.notion_client import NotionClient
+from notionary.notion_client import NotionClient
 
 
 class DatabaseInfoService:

notionary/{core/database/notion_database_manager.py → database/notion_database.py}

@@ -1,15 +1,15 @@
 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.notion_client import NotionClient
+from notionary.page.notion_page import NotionPage
 from notionary.util.logging_mixin import LoggingMixin
 from notionary.util.page_id_utils import format_uuid
 
 
-class NotionDatabaseManager(LoggingMixin):
+class NotionDatabase(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,59 +24,31 @@ 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[NotionPage]:
         """
         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
+            NotionPage 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.warning("Page creation failed: invalid response")
-            return None
-                
-        except Exception as e:
-            self.logger.error("Error creating blank page: %s", str(e))
-            return None
+                self.logger.info(
+                    "Created blank page %s in database %s", page_id, self.database_id
+                )
 
-    async def get_page_manager(self, page_id: str) -> Optional[NotionPageManager]:
-        """
-        Get a NotionPageManager for a specific page.
+                return NotionPage(page_id=page_id)
 
-        Args:
-            page_id: The ID of the page
+            self.logger.warning("Page creation failed: invalid response")
+            return None
 
-        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))
+            self.logger.error("Error creating blank page: %s", str(e))
             return None
 
     async def get_pages(
@@ -84,7 +56,7 @@ class NotionDatabaseManager(LoggingMixin):
         limit: int = 100,
         filter_conditions: Optional[Dict[str, Any]] = None,
         sorts: Optional[List[Dict[str, Any]]] = None,
-    ) -> List[NotionPageManager]:
+    ) -> List[NotionPage]:
         """
         Get all pages from the database.
 
@@ -94,7 +66,7 @@ class NotionDatabaseManager(LoggingMixin):
             sorts: Optional sort instructions for the database query
 
         Returns:
-            List of NotionPageManager instances for each page
+            List of NotionPage instances for each page
         """
         self.logger.debug(
             "Getting up to %d pages with filter: %s, sorts: %s",
@@ -103,7 +75,7 @@ class NotionDatabaseManager(LoggingMixin):
             sorts,
         )
 
-        pages: List[NotionPageManager] = []
+        pages: List[NotionPage] = []
         count = 0
 
         async for page in self.iter_pages(
@@ -127,7 +99,7 @@ class NotionDatabaseManager(LoggingMixin):
         page_size: int = 100,
         filter_conditions: Optional[Dict[str, Any]] = None,
         sorts: Optional[List[Dict[str, Any]]] = None,
-    ) -> AsyncGenerator[NotionPageManager, None]:
+    ) -> AsyncGenerator[NotionPage, None]:
         """
         Asynchronous generator that yields pages from the database.
         Directly queries the Notion API without using the schema.
@@ -138,7 +110,7 @@ class NotionDatabaseManager(LoggingMixin):
             sorts: Optional sort instructions for the database query
 
         Yields:
-            NotionPageManager instances for each page
+            NotionPage instances for each page
         """
         self.logger.debug(
             "Iterating pages with page_size: %d, filter: %s, sorts: %s",
@@ -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 = NotionPage(
+                    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,16 @@ 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 → database/notion_database_factory.py}

@@ -2,8 +2,8 @@ import logging
 from typing import List, Optional, Dict, Any
 from difflib import SequenceMatcher
 
-from notionary.core.notion_client import NotionClient
-from notionary.core.database.notion_database_manager import NotionDatabaseManager
+from notionary.database.notion_database import NotionDatabase
+from notionary.notion_client import NotionClient
 from notionary.exceptions.database_exceptions import (
     DatabaseConnectionError,
     DatabaseInitializationError,
@@ -29,7 +29,7 @@ class NotionDatabaseFactory(LoggingMixin):
     @classmethod
     async def from_database_id(
         cls, database_id: str, token: Optional[str] = None
-    ) -> NotionDatabaseManager:
+    ) -> NotionDatabase:
         """
         Create a NotionDatabaseManager from a database ID.
 
@@ -44,18 +44,17 @@ 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)
+            manager = NotionDatabase(formatted_id, token)
+
+            logger.info(
+                "Successfully created database manager for ID: %s", formatted_id
+            )
             return manager
 
         except DatabaseInitializationError:
-            # Re-raise the already typed exception
             raise
         except NotionDatabaseException:
-            # Re-raise other custom exceptions
             raise
         except Exception as e:
             error_msg = f"Error connecting to database {database_id}: {str(e)}"
@@ -65,7 +64,7 @@ class NotionDatabaseFactory(LoggingMixin):
     @classmethod
     async def from_database_name(
         cls, database_name: str, token: Optional[str] = None
-    ) -> NotionDatabaseManager:
+    ) -> NotionDatabase:
         """
         Create a NotionDatabaseManager by finding a database with a matching name.
         Uses fuzzy matching to find the closest match to the given name.
@@ -85,13 +84,11 @@ class NotionDatabaseFactory(LoggingMixin):
         try:
             logger.debug("Using search endpoint to find databases")
 
-            # Create search query for databases
             search_payload = {
                 "filter": {"property": "object", "value": "database"},
                 "page_size": 100,
             }
 
-            # Perform search
             response = await client.post("search", search_payload)
 
             if not response or "results" not in response:
@@ -136,11 +133,16 @@ 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)
+            manager = NotionDatabase(database_id, token)
 
-            logger.info(f"Successfully created database manager for '{matched_name}'")
+            logger.info("Successfully created database manager for '%s'", matched_name)
             await client.close()
             return manager
 
@@ -187,4 +189,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/{core/notion_client.py → 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/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 → page}/content/page_content_manager.py

@@ -1,15 +1,17 @@
 from typing import Any, Dict, List, Optional
 
-from notionary.core.converters.markdown_to_notion_converter import (
+from notionary.notion_client import NotionClient
+from notionary.converters.registry.block_element_registry import BlockElementRegistry
+
+from notionary.converters.markdown_to_notion_converter import (
     MarkdownToNotionConverter,
 )
-from notionary.core.converters.notion_to_markdown_converter import (
+from notionary.converters.notion_to_markdown_converter import (
     NotionToMarkdownConverter,
 )
-from notionary.core.converters.registry.block_element_registry import (
-    BlockElementRegistry,
+from notionary.page.content.notion_page_content_chunker import (
+    NotionPageContentChunker,
 )
-from notionary.core.notion_client import NotionClient
 from notionary.util.logging_mixin import LoggingMixin
 
 
@@ -28,15 +30,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 +69,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