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

notionary/elements/mention_element.py

@@ -0,0 +1,227 @@
+import re
+from typing import Dict, Any, Optional, List
+from typing_extensions import override
+
+from notionary.elements.notion_block_element import NotionBlockElement
+
+
+class MentionElement(NotionBlockElement):
+    """
+    Handles conversion between Markdown mentions and Notion mention elements.
+
+    Markdown mention syntax:
+    - @[page-id] - Mention a page by its ID
+    - @date[YYYY-MM-DD] - Mention a date
+    - @db[database-id] - Mention a database by its ID
+    """
+
+    MENTION_TYPES = {
+        "page": {
+            "pattern": r"@\[([0-9a-f-]+)\]",
+            "create_mention": lambda id_value: {
+                "type": "mention",
+                "mention": {"type": "page", "page": {"id": id_value}},
+            },
+            "get_plain_text": lambda mention: f"Page {mention['mention']['page']['id']}",
+            "to_markdown": lambda mention: f"@[{mention['mention']['page']['id']}]",
+        },
+        "date": {
+            "pattern": r"@date\[(\d{4}-\d{2}-\d{2})\]",
+            "create_mention": lambda date_value: {
+                "type": "mention",
+                "mention": {"type": "date", "date": {"start": date_value, "end": None}},
+            },
+            "get_plain_text": lambda mention: mention["mention"]["date"]["start"],
+            "to_markdown": lambda mention: f"@date[{mention['mention']['date']['start']}]",
+        },
+        "database": {
+            "pattern": r"@db\[([0-9a-f-]+)\]",
+            "create_mention": lambda db_id: {
+                "type": "mention",
+                "mention": {"type": "database", "database": {"id": db_id}},
+            },
+            "get_plain_text": lambda mention: f"Database {mention['mention']['database']['id']}",
+            "to_markdown": lambda mention: f"@db[{mention['mention']['database']['id']}]",
+        },
+    }
+
+    @override
+    @staticmethod
+    def match_markdown(text: str) -> bool:
+        """Check if text contains a markdown mention."""
+        for mention_type in MentionElement.MENTION_TYPES.values():
+            if re.search(mention_type["pattern"], text):
+                return True
+        return False
+
+    @override
+    @staticmethod
+    def match_notion(block: Dict[str, Any]) -> bool:
+        """Check if block contains a mention."""
+        supported_block_types = [
+            "paragraph",
+            "heading_1",
+            "heading_2",
+            "heading_3",
+            "bulleted_list_item",
+            "numbered_list_item",
+        ]
+
+        if block.get("type") not in supported_block_types:
+            return False
+
+        block_content = block.get(block.get("type"), {})
+        rich_text = block_content.get("rich_text", [])
+
+        return any(text_item.get("type") == "mention" for text_item in rich_text)
+
+    @override
+    @staticmethod
+    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
+        """Convert markdown text with mentions to a Notion paragraph block."""
+        if not MentionElement.match_markdown(text):
+            return None
+
+        rich_text = MentionElement._process_markdown_with_mentions(text)
+
+        return {
+            "type": "paragraph",
+            "paragraph": {"rich_text": rich_text, "color": "default"},
+        }
+
+    @staticmethod
+    def _process_markdown_with_mentions(text: str) -> List[Dict[str, Any]]:
+        """Convert markdown mentions to Notion rich_text format."""
+        mentions = []
+
+        for mention_type, config in MentionElement.MENTION_TYPES.items():
+            for match in re.finditer(config["pattern"], text):
+                mentions.append(
+                    {
+                        "start": match.start(),
+                        "end": match.end(),
+                        "type": mention_type,
+                        "value": match.group(1),
+                        "original": match.group(0),
+                    }
+                )
+
+        mentions.sort(key=lambda m: m["start"])
+
+        # Build rich_text list
+        rich_text = []
+        position = 0
+
+        for mention in mentions:
+            if mention["start"] > position:
+                rich_text.append(
+                    MentionElement._create_text_item(text[position : mention["start"]])
+                )
+
+            # Add the mention
+            mention_obj = MentionElement.MENTION_TYPES[mention["type"]][
+                "create_mention"
+            ](mention["value"])
+
+            # Add annotations and plain text
+            mention_obj["annotations"] = MentionElement._default_annotations()
+            mention_obj["plain_text"] = MentionElement.MENTION_TYPES[mention["type"]][
+                "get_plain_text"
+            ](mention_obj)
+
+            rich_text.append(mention_obj)
+            position = mention["end"]
+
+        # Add remaining text if any
+        if position < len(text):
+            rich_text.append(MentionElement._create_text_item(text[position:]))
+
+        return rich_text
+
+    @staticmethod
+    def _create_text_item(content: str) -> Dict[str, Any]:
+        """Create a text item with default annotations."""
+        text_item = {
+            "type": "text",
+            "text": {"content": content, "link": None},
+            "annotations": MentionElement._default_annotations(),
+            "plain_text": content,
+        }
+        return text_item
+
+    @staticmethod
+    def _default_annotations() -> Dict[str, Any]:
+        """Return default annotations for rich text."""
+        return {
+            "bold": False,
+            "italic": False,
+            "strikethrough": False,
+            "underline": False,
+            "code": False,
+            "color": "default",
+        }
+
+    @override
+    @staticmethod
+    def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
+        """Extract mentions from Notion block and convert to markdown format."""
+        block_type = block.get("type")
+        if not block_type or block_type not in block:
+            return None
+
+        block_content = block.get(block_type, {})
+        rich_text = block_content.get("rich_text", [])
+
+        processed_text = MentionElement._process_rich_text_with_mentions(rich_text)
+
+        if processed_text:
+            return processed_text
+
+        return None
+
+    @staticmethod
+    def _process_rich_text_with_mentions(rich_text: List[Dict[str, Any]]) -> str:
+        """Convert rich text with mentions to markdown string."""
+        result = []
+
+        for item in rich_text:
+            if item.get("type") == "mention":
+                mention = item.get("mention", {})
+                mention_type = mention.get("type")
+
+                if mention_type in MentionElement.MENTION_TYPES:
+                    result.append(
+                        MentionElement.MENTION_TYPES[mention_type]["to_markdown"](item)
+                    )
+                else:
+                    result.append(item.get("plain_text", "@[unknown]"))
+            else:
+                result.append(item.get("plain_text", ""))
+
+        return "".join(result)
+
+    @override
+    @staticmethod
+    def is_multiline() -> bool:
+        return False
+
+    @classmethod
+    def get_llm_prompt_content(cls) -> dict:
+        """Information about this element for LLM-based processing."""
+        return {
+            "description": "References to Notion pages, databases, or dates within text content.",
+            "when_to_use": "When you want to link to other Notion content within your text.",
+            "syntax": [
+                "@[page-id] - Reference to a Notion page",
+                "@date[YYYY-MM-DD] - Reference to a date",
+                "@db[database-id] - Reference to a Notion database",
+            ],
+            "examples": [
+                "Check the meeting notes at @[1a6389d5-7bd3-80c5-9a87-e90b034989d0]",
+                "Deadline is @date[2023-12-31]",
+                "Use the structure in @db[1a6389d5-7bd3-80e9-b199-000cfb3fa0b3]",
+            ],
+            "limitations": [
+                "Mentions require knowing the internal IDs of the pages or databases you want to reference"
+            ],
+        }

notionary/{converters/elements → elements}/paragraph_element.py

@@ -1,8 +1,8 @@
 from typing import Dict, Any, Optional
 from typing_extensions import override
 
-from notionary.converters.elements.notion_block_element import NotionBlockElement
-from notionary.converters.elements.text_inline_formatter import TextInlineFormatter
+from notionary.elements.notion_block_element import NotionBlockElement
+from notionary.elements.text_inline_formatter import TextInlineFormatter
 
 
 class ParagraphElement(NotionBlockElement):

notionary/{converters/elements → elements}/qoute_element.py

@@ -2,7 +2,7 @@ import re
 from typing import Dict, Any, Optional, List, Tuple
 from typing_extensions import override
 
-from notionary.converters.elements.notion_block_element import NotionBlockElement
+from notionary.elements.notion_block_element import NotionBlockElement
 
 
 class QuoteElement(NotionBlockElement):

notionary/{converters/elements → elements}/table_element.py

@@ -3,8 +3,8 @@
 from typing import Dict, Any, Optional, List, Tuple
 from typing_extensions import override
 import re
-from notionary.converters.elements.notion_block_element import NotionBlockElement
-from notionary.converters.elements.text_inline_formatter import TextInlineFormatter
+from notionary.elements.notion_block_element import NotionBlockElement
+from notionary.elements.text_inline_formatter import TextInlineFormatter
 
 
 class TableElement(NotionBlockElement):

notionary/{converters/elements → elements}/todo_lists.py

@@ -1,8 +1,8 @@
 import re
 from typing import Dict, Any, Optional
 from typing_extensions import override
-from notionary.converters.elements.notion_block_element import NotionBlockElement
-from notionary.converters.elements.text_inline_formatter import TextInlineFormatter
+from notionary.elements.notion_block_element import NotionBlockElement
+from notionary.elements.text_inline_formatter import TextInlineFormatter
 
 
 class TodoElement(NotionBlockElement):

notionary/{converters/elements → elements}/toggle_element.py

@@ -1,7 +1,7 @@
 import re
 from typing import Dict, Any, Optional, List, Tuple, Callable
 
-from notionary.converters.elements.notion_block_element import NotionBlockElement
+from notionary.elements.notion_block_element import NotionBlockElement
 
 
 class ToggleElement(NotionBlockElement):

notionary/{converters/elements → elements}/video_element.py

@@ -1,6 +1,6 @@
 import re
 from typing import Dict, Any, Optional, List
-from notionary.converters.elements.notion_block_element import NotionBlockElement
+from notionary.elements.notion_block_element import NotionBlockElement
 
 
 class VideoElement(NotionBlockElement):

notionary/notion_client.py

@@ -9,8 +9,6 @@ from notionary.util.logging_mixin import LoggingMixin
 
 
 class HttpMethod(Enum):
-    """Enum für HTTP-Methoden."""
-
     GET = "get"
     POST = "post"
     PATCH = "patch"
@@ -42,31 +40,84 @@ class NotionClient(LoggingMixin):
 
     @classmethod
     async def close_all(cls):
+        """
+        Closes all active NotionClient instances and releases resources.
+        """
         for instance in list(cls._instances):
             await instance.close()
 
-    async def close(self):
+    async def close(self):#
+        """
+        Closes the HTTP client for this instance and releases resources.
+        """
         if hasattr(self, "client") and self.client:
             await self.client.aclose()
             self.client = None
 
     async def get(self, endpoint: str) -> Optional[Dict[str, Any]]:
+        """
+        Sends a GET request to the specified Notion API endpoint.
+
+        Args:
+            endpoint: The relative API path (e.g., 'databases/<id>').
+
+        Returns:
+            A dictionary with the response data, or None if the request failed.
+        """
         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}")
+        """
+        Fetches metadata for a Notion page by its ID.
+
+        Args:
+            page_id: The Notion page ID.
 
+        Returns:
+            A dictionary with the page data, or None if the request failed.
+        """
+        return await self.get(f"pages/{page_id}")
+    
     async def post(
         self, endpoint: str, data: Optional[Dict[str, Any]] = None
     ) -> Optional[Dict[str, Any]]:
+        """
+        Sends a POST request to the specified Notion API endpoint.
+
+        Args:
+            endpoint: The relative API path.
+            data: Optional dictionary payload to send with the request.
+
+        Returns:
+            A dictionary with the response data, or None if the request failed.
+        """
         return await self._make_request(HttpMethod.POST, endpoint, data)
 
     async def patch(
         self, endpoint: str, data: Optional[Dict[str, Any]] = None
     ) -> Optional[Dict[str, Any]]:
+        """
+        Sends a PATCH request to the specified Notion API endpoint.
+
+        Args:
+            endpoint: The relative API path.
+            data: Optional dictionary payload to send with the request.
+
+        Returns:
+            A dictionary with the response data, or None if the request failed.
+        """
         return await self._make_request(HttpMethod.PATCH, endpoint, data)
 
     async def delete(self, endpoint: str) -> bool:
+        """
+        Sends a DELETE request to the specified Notion API endpoint.
+
+        Args:
+            endpoint: The relative API path.
+
+        Returns:
+            True if the request was successful, False otherwise.
+        """
         result = await self._make_request(HttpMethod.DELETE, endpoint)
         return result is not None
 
@@ -124,7 +175,6 @@ class NotionClient(LoggingMixin):
                 )
                 return
 
-            # Versuche, Cleanup Task zu erstellen
             loop.create_task(self.close())
             self.logger.debug("Created cleanup task for NotionClient")
         except RuntimeError:

notionary/page/content/page_content_manager.py

@@ -1,12 +1,13 @@
+import json
 from typing import Any, Dict, List, Optional
 
+from notionary.elements.block_element_registry import BlockElementRegistry
 from notionary.notion_client import NotionClient
-from notionary.converters.registry.block_element_registry import BlockElementRegistry
 
-from notionary.converters.markdown_to_notion_converter import (
+from notionary.page.markdown_to_notion_converter import (
     MarkdownToNotionConverter,
 )
-from notionary.converters.notion_to_markdown_converter import (
+from notionary.page.notion_to_markdown_converter import (
     NotionToMarkdownConverter,
 )
 from notionary.page.content.notion_page_content_chunker import (
@@ -38,8 +39,8 @@ class PageContentManager(LoggingMixin):
         """
         try:
             blocks = self._markdown_to_notion_converter.convert(markdown_text)
+            print(json.dumps(blocks, indent=4))
 
-            # Fix any blocks that exceed Notion's content length limits
             fixed_blocks = self._chunker.fix_blocks_content_length(blocks)
 
             result = await self._client.patch(
@@ -54,26 +55,81 @@ class PageContentManager(LoggingMixin):
             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")
-        if not blocks:
-            return "No content to delete."
+    async def has_database_descendant(self, block_id: str) -> bool:
+        """
+        Check if a block or any of its descendants is a database.
+        """
+        resp = await self._client.get(f"blocks/{block_id}/children")
+        children = resp.get("results", []) if resp else []
+
+        for child in children:
+            block_type = child.get("type")
+            if block_type in ["child_database", "database", "linked_database"]:
+                return True
 
-        results = blocks.get("results", [])
-        if not results:
-            return "No content to delete."
+            if child.get("has_children", False):
+                if await self.has_database_descendant(child["id"]):
+                    return True
 
+        return False
+
+    async def delete_block_with_children(
+        self, block: Dict[str, Any], skip_databases: bool
+    ) -> tuple[int, int]:
+        """
+        Delete a block and all its children, optionally skipping databases.
+        Returns a tuple of (deleted_count, skipped_count).
+        """
         deleted = 0
         skipped = 0
-        for block in results:
-            if block.get("type") in ["child_database", "database", "linked_database"]:
-                skipped += 1
-                continue
 
-            if await self._client.delete(f"blocks/{block['id']}"):
-                deleted += 1
+        block_type = block.get("type")
+        if skip_databases and block_type in [
+            "child_database",
+            "database",
+            "linked_database",
+        ]:
+            return 0, 1
+
+        if skip_databases and await self.has_database_descendant(block["id"]):
+            return 0, 1
+
+        # Process children first
+        if block.get("has_children", False):
+            children_resp = await self._client.get(f"blocks/{block['id']}/children")
+            for child in children_resp.get("results", []):
+                child_deleted, child_skipped = await self.delete_block_with_children(
+                    child, skip_databases
+                )
+                deleted += child_deleted
+                skipped += child_skipped
+
+        # Then delete the block itself
+        if await self._client.delete(f"blocks/{block['id']}"):
+            deleted += 1
+
+        return deleted, skipped
+
+    async def clear(self, skip_databases: bool = True) -> str:
+        """
+        Clear the content of the page, optionally preserving databases.
+        """
+        blocks_resp = await self._client.get(f"blocks/{self.page_id}/children")
+        results = blocks_resp.get("results", []) if blocks_resp else []
 
-        return f"Deleted {deleted}/{len(results)} blocks. Skipped {skipped} database blocks."
+        total_deleted = 0
+        total_skipped = 0
+
+        for block in results:
+            deleted, skipped = await self.delete_block_with_children(
+                block, skip_databases
+            )
+            total_deleted += deleted
+            total_skipped += skipped
+
+        return (
+            f"Deleted {total_deleted} blocks. Skipped {total_skipped} database blocks."
+        )
 
     async def get_blocks(self) -> List[Dict[str, Any]]:
         result = await self._client.get(f"blocks/{self.page_id}/children")
@@ -89,17 +145,33 @@ class PageContentManager(LoggingMixin):
             return []
         return result.get("results", [])
 
-    async def get_page_blocks_with_children(self) -> List[Dict[str, Any]]:
-        blocks = await self.get_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 block.get("has_children"):
-                block_id = block.get("id")
-                if block_id:
-                    children = await self.get_block_children(block_id)
-                    if children:
-                        block["children"] = children
+            if not block.get("has_children"):
+                continue
+
+            block_id = block.get("id")
+            if not block_id:
+                continue
+
+            # Recursive call for nested blocks
+            children = await self.get_page_blocks_with_children(block_id)
+            if children:
+                block["children"] = children
+
         return blocks
 
     async def get_text(self) -> str:
         blocks = await self.get_page_blocks_with_children()
+        print(json.dumps(blocks, indent=4))
         return self._notion_to_markdown_converter.convert(blocks)

notionary/{converters → page}/markdown_to_notion_converter.py

@@ -1,9 +1,7 @@
 from typing import Dict, Any, List, Optional, Tuple
 
-from notionary.converters.registry.block_element_registry import (
-    BlockElementRegistry,
-)
-from notionary.converters.registry.block_element_registry_builder import (
+from notionary.elements.block_element_registry import BlockElementRegistry
+from notionary.elements.block_element_registry_builder import (
     BlockElementRegistryBuilder,
 )
 

notionary/page/notion_page.py

@@ -1,9 +1,8 @@
 import re
 from typing import Any, Dict, List, Optional, Union
-from notionary.converters.registry.block_element_registry import (
-    BlockElementRegistry,
-)
-from notionary.converters.registry.block_element_registry_builder import (
+
+from notionary.elements.block_element_registry import BlockElementRegistry
+from notionary.elements.block_element_registry_builder import (
     BlockElementRegistryBuilder,
 )
 from notionary.notion_client import NotionClient
@@ -412,6 +411,25 @@ class NotionPage(LoggingMixin):
         """
         return await self._relation_manager.get_all_relations()
 
+    async def get_last_edited_time(self) -> str:
+        """
+        Get the timestamp when the page was last edited.
+
+        Returns:
+            str: ISO 8601 formatted timestamp string of when the page was last edited.
+        """
+        try:
+            page_data = await self._client.get_page(self._page_id)
+            if "last_edited_time" in page_data:
+                return page_data["last_edited_time"]
+
+            self.logger.warning("last_edited_time not found in page data")
+            return ""
+
+        except Exception as e:
+            self.logger.error("Error retrieving last edited time: %s", str(e))
+            return ""
+
     async def _load_page_title(self) -> str:
         """
         Load the page title from Notion API if not already loaded.
@@ -483,7 +501,7 @@ class NotionPage(LoggingMixin):
         clean_id = self._page_id.replace("-", "")
 
         return f"https://www.notion.so/{url_title}{clean_id}"
-    
+
     async def _get_db_property_service(self) -> Optional[DatabasePropertyService]:
         """
         Gets the database property service, initializing it if necessary.

notionary/page/notion_page_factory.py

@@ -176,9 +176,7 @@ class NotionPageFactory(LoggingMixin):
                 best_score,
             )
 
-            page = NotionPage(
-                page_id=page_id, title=matched_name, token=token
-            )
+            page = NotionPage(page_id=page_id, title=matched_name, token=token)
 
             logger.info("Successfully created page instance for '%s'", matched_name)
             await client.close()
@@ -242,15 +240,3 @@ class NotionPageFactory(LoggingMixin):
                 text_parts.append(text_obj["plain_text"])
 
         return "".join(text_parts)
-
-
-async def demo():
-    clipboard = await NotionPageFactory.from_page_name("Jarvis Clipboard")
-    icon = await clipboard.get_icon()
-    print(f"Icon: {icon}")
-
-
-if __name__ == "__main__":
-    import asyncio
-
-    asyncio.run(demo())