notionary 0.1.14__tar.gz → 0.1.16__tar.gz

{notionary-0.1.14 → notionary-0.1.16}/PKG-INFO

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

{notionary-0.1.14 → notionary-0.1.16}/notionary/elements/block_element_registry_builder.py

@@ -155,7 +155,7 @@ class BlockElementRegistryBuilder:
         Returns:
             Self for method chaining
         """
-        return self.add_element(element_class)  # add_element already handles this logic
+        return self.add_element(element_class)
 
     def _ensure_paragraph_at_end(self) -> None:
         """
@@ -309,15 +309,6 @@ class BlockElementRegistryBuilder:
         """
         return self.add_element(AudioElement)
 
-    def with_rich_content(self) -> BlockElementRegistryBuilder:
-        """
-        Add support for rich content elements (callouts, toggles, etc.).
-
-        Returns:
-            Self for method chaining
-        """
-        return self.with_callouts().with_toggles().with_quotes()
-
     def with_media_support(self) -> BlockElementRegistryBuilder:
         """
         Add support for media elements (images, videos, audio).
@@ -327,15 +318,6 @@ class BlockElementRegistryBuilder:
         """
         return self.with_images().with_videos().with_audio()
 
-    def with_task_support(self) -> BlockElementRegistryBuilder:
-        """
-        Add support for task-related elements (todos).
-
-        Returns:
-            Self for method chaining
-        """
-        return self.with_todos()
-    
     def with_mention(self) -> BlockElementRegistryBuilder:
         return self.add_element(MentionElement)
 

notionary-0.1.16/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-0.1.14 → notionary-0.1.16}/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
 

notionary-0.1.16/notionary/page/content/page_content_manager.py

@@ -0,0 +1,177 @@
+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.page.markdown_to_notion_converter import (
+    MarkdownToNotionConverter,
+)
+from notionary.page.notion_to_markdown_converter import (
+    NotionToMarkdownConverter,
+)
+from notionary.page.content.notion_page_content_chunker import (
+    NotionPageContentChunker,
+)
+from notionary.util.logging_mixin import LoggingMixin
+
+
+class PageContentManager(LoggingMixin):
+    def __init__(
+        self,
+        page_id: str,
+        client: NotionClient,
+        block_registry: Optional[BlockElementRegistry] = None,
+    ):
+        self.page_id = page_id
+        self._client = client
+        self._markdown_to_notion_converter = MarkdownToNotionConverter(
+            block_registry=block_registry
+        )
+        self._notion_to_markdown_converter = NotionToMarkdownConverter(
+            block_registry=block_registry
+        )
+        self._chunker = NotionPageContentChunker()
+
+    async def append_markdown(self, markdown_text: str) -> str:
+        """
+        Append markdown text to a Notion page, automatically handling content length limits.
+        """
+        try:
+            blocks = self._markdown_to_notion_converter.convert(markdown_text)
+            print(json.dumps(blocks, indent=4))
+
+            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 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
+
+            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
+
+        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 []
+
+        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")
+        if not result:
+            self.logger.error("Error retrieving page content: %s", result.error)
+            return []
+        return result.get("results", [])
+
+    async def get_block_children(self, block_id: str) -> List[Dict[str, Any]]:
+        result = await self._client.get(f"blocks/{block_id}/children")
+        if not result:
+            self.logger.error("Error retrieving block children: %s", result.error)
+            return []
+        return result.get("results", [])
+
+    async def get_page_blocks_with_children(
+        self, parent_id: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        blocks = (
+            await self.get_blocks()
+            if parent_id is None
+            else await self.get_block_children(parent_id)
+        )
+        if not blocks:
+            return []
+
+        for block in blocks:
+            if not block.get("has_children"):
+                continue
+
+            block_id = block.get("id")
+            if not block_id:
+                continue
+
+            # 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)