notionary 0.1.14__tar.gz → 0.1.15__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionary
-Version: 0.1.14
+Version: 0.1.15
 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.15}/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.15/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.15}/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.15/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)

{notionary-0.1.14 → notionary-0.1.15}/notionary/page/notion_to_markdown_converter.py

@@ -58,75 +58,85 @@ class NotionToMarkdownConverter:
             return ""
 
         block_markdown = self._block_registry.notion_to_markdown(block)
-        
+
         if not self._has_children(block):
             return block_markdown
-            
+
         children_markdown = self.convert(block["children"])
         if not children_markdown:
             return block_markdown
-        
+
         block_type = block.get("type", "")
-        
+
         if block_type == "toggle":
             return self._format_toggle_with_children(block_markdown, children_markdown)
-        
+
         if block_type in ["numbered_list_item", "bulleted_list_item"]:
-            return self._format_list_item_with_children(block_markdown, children_markdown)
-        
+            return self._format_list_item_with_children(
+                block_markdown, children_markdown
+            )
+
         if block_type in ["column_list", "column"]:
             return children_markdown
-        
-        return self._format_standard_block_with_children(block_markdown, children_markdown)
+
+        return self._format_standard_block_with_children(
+            block_markdown, children_markdown
+        )
 
     def _has_children(self, block: Dict[str, Any]) -> bool:
         """
         Check if block has children that need processing.
-        
+
         Args:
             block: Notion block to check
-            
+
         Returns:
             True if block has children to process
         """
         return block.get("has_children", False) and "children" in block
 
-    def _format_toggle_with_children(self, toggle_markdown: str, children_markdown: str) -> str:
+    def _format_toggle_with_children(
+        self, toggle_markdown: str, children_markdown: str
+    ) -> str:
         """
         Format toggle block with its children content.
-        
+
         Args:
             toggle_markdown: Markdown for the toggle itself
             children_markdown: Markdown for toggle's children
-            
+
         Returns:
             Formatted markdown with indented children
         """
         indented_children = self._indent_text(children_markdown)
         return f"{toggle_markdown}\n{indented_children}"
 
-    def _format_list_item_with_children(self, item_markdown: str, children_markdown: str) -> str:
+    def _format_list_item_with_children(
+        self, item_markdown: str, children_markdown: str
+    ) -> str:
         """
         Format list item with its children content.
-        
+
         Args:
             item_markdown: Markdown for the list item itself
             children_markdown: Markdown for item's children
-            
+
         Returns:
             Formatted markdown with indented children
         """
         indented_children = self._indent_text(children_markdown)
         return f"{item_markdown}\n{indented_children}"
 
-    def _format_standard_block_with_children(self, block_markdown: str, children_markdown: str) -> str:
+    def _format_standard_block_with_children(
+        self, block_markdown: str, children_markdown: str
+    ) -> str:
         """
         Format standard block with its children content.
-        
+
         Args:
             block_markdown: Markdown for the block itself
             children_markdown: Markdown for block's children
-            
+
         Returns:
             Formatted markdown with children after block
         """
@@ -135,11 +145,11 @@ class NotionToMarkdownConverter:
     def _indent_text(self, text: str, spaces: int = 4) -> str:
         """
         Indent each line of text with specified number of spaces.
-        
+
         Args:
             text: Text to indent
             spaces: Number of spaces to use for indentation
-            
+
         Returns:
             Indented text
         """
@@ -149,27 +159,29 @@ class NotionToMarkdownConverter:
     def extract_toggle_content(self, blocks: List[Dict[str, Any]]) -> str:
         """
         Extract only the content of toggles from blocks.
-        
+
         Args:
             blocks: List of Notion blocks
-            
+
         Returns:
             Markdown text with toggle contents
         """
         if not blocks:
             return ""
-            
+
         toggle_contents = []
-        
+
         for block in blocks:
             self._extract_toggle_content_recursive(block, toggle_contents)
-            
+
         return "\n".join(toggle_contents)
 
-    def _extract_toggle_content_recursive(self, block: Dict[str, Any], result: List[str]) -> None:
+    def _extract_toggle_content_recursive(
+        self, block: Dict[str, Any], result: List[str]
+    ) -> None:
         """
         Recursively extract toggle content from a block and its children.
-        
+
         Args:
             block: Block to process
             result: List to collect toggle content
@@ -177,7 +189,7 @@ class NotionToMarkdownConverter:
         if self._is_toggle_with_children(block):
             self._add_toggle_header_to_result(block, result)
             self._add_toggle_children_to_result(block, result)
-        
+
         if self._has_children(block):
             for child in block["children"]:
                 self._extract_toggle_content_recursive(child, result)
@@ -185,19 +197,21 @@ class NotionToMarkdownConverter:
     def _is_toggle_with_children(self, block: Dict[str, Any]) -> bool:
         """
         Check if block is a toggle with children.
-        
+
         Args:
             block: Block to check
-            
+
         Returns:
             True if block is a toggle with children
         """
         return block.get("type") == "toggle" and "children" in block
 
-    def _add_toggle_header_to_result(self, block: Dict[str, Any], result: List[str]) -> None:
+    def _add_toggle_header_to_result(
+        self, block: Dict[str, Any], result: List[str]
+    ) -> None:
         """
         Add toggle header text to result list.
-        
+
         Args:
             block: Toggle block
             result: List to add header to
@@ -205,14 +219,16 @@ class NotionToMarkdownConverter:
         toggle_text = self._extract_text_from_rich_text(
             block.get("toggle", {}).get("rich_text", [])
         )
-        
+
         if toggle_text:
             result.append(f"### {toggle_text}")
 
-    def _add_toggle_children_to_result(self, block: Dict[str, Any], result: List[str]) -> None:
+    def _add_toggle_children_to_result(
+        self, block: Dict[str, Any], result: List[str]
+    ) -> None:
         """
         Add formatted toggle children to result list.
-        
+
         Args:
             block: Toggle block with children
             result: List to add children content to
@@ -221,25 +237,25 @@ class NotionToMarkdownConverter:
             child_type = child.get("type")
             if not (child_type and child_type in child):
                 continue
-                
+
             child_text = self._extract_text_from_rich_text(
                 child.get(child_type, {}).get("rich_text", [])
             )
-            
+
             if child_text:
                 result.append(f"- {child_text}")
 
     def _extract_text_from_rich_text(self, rich_text: List[Dict[str, Any]]) -> str:
         """
         Extract plain text from Notion's rich text array.
-        
+
         Args:
             rich_text: List of rich text objects
-            
+
         Returns:
             Concatenated plain text
         """
         if not rich_text:
             return ""
-            
-        return "".join([rt.get("plain_text", "") for rt in rich_text])
+
+        return "".join([rt.get("plain_text", "") for rt in rich_text])

{notionary-0.1.14 → notionary-0.1.15}/notionary.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionary
-Version: 0.1.14
+Version: 0.1.15
 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.15}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_namespace_packages
 
 setup(
     name="notionary",
-    version="0.1.14",
+    version="0.1.15",
     packages=find_namespace_packages(include=["notionary*"]),
     install_requires=[
         "notion-client>=2.0.0",

notionary-0.1.14/notionary/elements/mention_element.py

@@ -1,135 +0,0 @@
-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
-    
-    Note: This element primarily supports Notion-to-Markdown conversion,
-    as page mentions in Markdown would typically require knowing internal page IDs.
-    """
-    
-    @override
-    @staticmethod
-    def match_markdown(text: str) -> bool:
-        """Check if text is a markdown mention."""
-        return False
-    
-    @override
-    @staticmethod
-    def match_notion(block: Dict[str, Any]) -> bool:
-        """Check if block contains a mention."""
-        if block.get("type") not in ["paragraph", "heading_1", "heading_2", "heading_3", "bulleted_list_item", "numbered_list_item"]:
-            return False
-            
-        block_content = block.get(block.get("type"), {})
-        rich_text = block_content.get("rich_text", [])
-        
-        for text_item in rich_text:
-            if text_item.get("type") == "mention":
-                return True
-                
-        return False
-    
-    @override
-    @staticmethod
-    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
-        """Convert markdown mention to Notion mention block."""
-        # This would be handled within rich text processing rather than as a standalone block
-        return None
-    
-    @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 MentionElement._is_only_mentions(rich_text):
-            return processed_text
-            
-        return None
-    
-    @staticmethod
-    def _process_rich_text_with_mentions(rich_text: List[Dict[str, Any]]) -> str:
-        """Process rich text array and convert any mentions to markdown format."""
-        result = []
-        
-        for item in rich_text:
-            if item.get("type") == "mention":
-                mention = item.get("mention", {})
-                mention_type = mention.get("type")
-                
-                if mention_type == "page":
-                    page_id = mention.get("page", {}).get("id", "")
-                    result.append(f"@[{page_id}]")
-                elif mention_type == "user":
-                    user_id = mention.get("user", {}).get("id", "")
-                    result.append(f"@user[{user_id}]")
-                elif mention_type == "date":
-                    date_value = mention.get("date", {}).get("start", "")
-                    result.append(f"@date[{date_value}]")
-                elif mention_type == "database":
-                    db_id = mention.get("database", {}).get("id", "")
-                    result.append(f"@db[{db_id}]")
-                else:
-                    # Unknown mention type, fallback to plain text if available
-                    result.append(item.get("plain_text", "@[unknown]"))
-            else:
-                # Regular text item
-                result.append(item.get("plain_text", ""))
-                
-        return "".join(result)
-    
-    @staticmethod
-    def _is_only_mentions(rich_text: List[Dict[str, Any]]) -> bool:
-        """Check if rich_text array contains only mentions."""
-        if not rich_text:
-            return False
-            
-        for item in rich_text:
-            if item.get("type") != "mention":
-                return False
-                
-        return True
-    
-    @override
-    @staticmethod
-    def is_multiline() -> bool:
-        return False
-    
-    @classmethod
-    def get_llm_prompt_content(cls) -> dict:
-        """
-        Returns a dictionary with all information needed for LLM prompts about this element.
-        """
-        return {
-            "description": "References to Notion pages, users, databases, or dates within text content.",
-            "when_to_use": "Mentions are typically part of rich text content rather than standalone elements. They're used to link to other Notion content or users.",
-            "syntax": [
-                "@[page-id] - Reference to a Notion page",
-                "@user[user-id] - Reference to a Notion user",
-                "@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]",
-                "Please review this with @user[d3dbbbd7-ec00-4204-94d9-e4a46e4928db]",
-                "Deadline is @date[2023-12-31]"
-            ],
-            "limitations": [
-                "Mentions are typically created through Notion's UI rather than direct markdown input",
-                "When converting Notion content to markdown, mentions are represented with their internal IDs"
-            ]
-        }

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

@@ -1,106 +0,0 @@
-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)
-
-            # 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")
-        if not blocks:
-            return "No content to delete."
-
-        results = blocks.get("results", [])
-        if not results:
-            return "No content to delete."
-
-        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
-
-        return f"Deleted {deleted}/{len(results)} blocks. Skipped {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) -> List[Dict[str, Any]]:
-        blocks = await self.get_blocks()
-        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
-        return blocks
-
-    async def get_text(self) -> str:
-        blocks = await self.get_page_blocks_with_children()
-        return self._notion_to_markdown_converter.convert(blocks)