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

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/elements/mention_element.py

@@ -1,48 +1,166 @@
+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
-    
-    Note: This element primarily supports Notion-to-Markdown conversion,
-    as page mentions in Markdown would typically require knowing internal page IDs.
+    - @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 is a markdown mention."""
+        """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."""
-        if block.get("type") not in ["paragraph", "heading_1", "heading_2", "heading_3", "bulleted_list_item", "numbered_list_item"]:
+        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", [])
-        
-        for text_item in rich_text:
-            if text_item.get("type") == "mention":
-                return True
-                
-        return False
-    
+
+        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 mention to Notion mention block."""
-        # This would be handled within rich text processing rather than as a standalone block
-        return None
-    
+        """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]:
@@ -50,86 +168,60 @@ class MentionElement(NotionBlockElement):
         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):
+
+        if processed_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."""
+        """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 == "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}]")
+
+                if mention_type in MentionElement.MENTION_TYPES:
+                    result.append(
+                        MentionElement.MENTION_TYPES[mention_type]["to_markdown"](item)
+                    )
                 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.
-        """
+        """Information about this element for LLM-based processing."""
         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.",
+            "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",
-                "@user[user-id] - Reference to a Notion user",
                 "@date[YYYY-MM-DD] - Reference to a date",
-                "@db[database-id] - Reference to a Notion database"
+                "@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]"
+                "Deadline is @date[2023-12-31]",
+                "Use the structure in @db[1a6389d5-7bd3-80e9-b199-000cfb3fa0b3]",
             ],
             "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"
-            ]
-        }
+                "Mentions require knowing the internal IDs of the pages or databases you want to reference"
+            ],
+        }

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/page/content/page_content_manager.py

@@ -39,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(
@@ -55,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")
@@ -90,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/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.dist-info → notionary-0.1.15.dist-info}/METADATA

@@ -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.dist-info → notionary-0.1.15.dist-info}/RECORD

@@ -1,5 +1,5 @@
 notionary/__init__.py,sha256=sVqdwzMQcc9jf6FKi1qflilsx8rnWzluVhWewVi5gyI,717
-notionary/notion_client.py,sha256=gRyTBVuCZCQod6L18VxzKl38Tn5oXdE0gPl7yGG8anQ,4446
+notionary/notion_client.py,sha256=NPPK7zId6EaC-hQeFJ7geaiROGtZfmc8cVP2nQez5DU,6040
 notionary/database/database_discovery.py,sha256=qDGFhXG9s-_6CXdRg8tMiwX4dvX7jLjgAUFPSNlYtlI,4506
 notionary/database/database_info_service.py,sha256=Ig6gx8jUSPYORJvfgEV5kV6t72pZQsWU8HPMqd43B-o,1336
 notionary/database/notion_database.py,sha256=RY5MlXNE5DVNWLC_Derljsz87ZMHkE-05Vgm80kvLxg,7250
@@ -7,7 +7,7 @@ notionary/database/notion_database_factory.py,sha256=Af57yaUHidD8TKJ8uyXOc2nnqHm
 notionary/database/models/page_result.py,sha256=Vmm5_oYpYAkIIJVoTd1ZZGloeC3cmFLMYP255mAmtaw,233
 notionary/elements/audio_element.py,sha256=XLARz5zlPPW_Qof6uhcYXFmyYzyS1fLdxdfsvh6GMOs,5589
 notionary/elements/block_element_registry.py,sha256=2mEbCEIPRY15qk6NYcq9vf7Bq_5vuu1xbiJatoLFf7w,8530
-notionary/elements/block_element_registry_builder.py,sha256=qPIGCAdzeZ3Xubxp1tysH8DqJMPZ7q1VEl0AbCsS01s,12107
+notionary/elements/block_element_registry_builder.py,sha256=xfZWJaamYCyw-aIU8TXTcAncVJaLpN7ioJRLYQxTbCo,11529
 notionary/elements/bookmark_element.py,sha256=83ciz2THxjeq7ofn-Xz9sG1Ifzm_gkIDmOo0A-pNsSo,8577
 notionary/elements/callout_element.py,sha256=K8yk7nE3WP8nskJKbMunkRDFlhSCXrONmYS6hELN6QE,5932
 notionary/elements/code_block_element.py,sha256=wbW_PfH6QBUFVfeELESuLiI5-GmLm2YUFP4xwFHgNV4,5173
@@ -17,7 +17,7 @@ notionary/elements/embed_element.py,sha256=LZjbSfwq0v8NGzwfUXpnGwvJ34IjYDwZzqyxV
 notionary/elements/heading_element.py,sha256=GsfEg5XtohmtO8PBP9giezIg6pRWQ_CdPXjh7jOiytw,2756
 notionary/elements/image_element.py,sha256=663H_FzE_bsovps3uCV12trNTmMAWBu5Ko1tSBNu2V4,4845
 notionary/elements/list_element.py,sha256=-f4mPRPesqFYYXfiiqGpnADeAY2ZAF1sTDtkLcejvLg,4846
-notionary/elements/mention_element.py,sha256=vltFnUJs83tIezqevSrMzXhICZFWyA28zflWd0Dmr-E,5497
+notionary/elements/mention_element.py,sha256=N1AcE8daMs6sDJGidQ8vvtHj30Do3K7x-4lW2aAYthU,8274
 notionary/elements/notion_block_element.py,sha256=lLRBDXhBeRaRzkbvdpYpr-U9nbkd62oVtqdSe-svT4c,1746
 notionary/elements/paragraph_element.py,sha256=ULSPcwy_JbnKdQkMy-xMs_KtYI8k5uxh6b4EGMNldTk,2734
 notionary/elements/qoute_element.py,sha256=3I2a7KboPF5QF6afu99HSIa62YUNfDJ6oaSDgyc9NjA,9041
@@ -31,9 +31,9 @@ notionary/exceptions/page_creation_exception.py,sha256=4v7IuZD6GsQLrqhDLriGjuG3M
 notionary/page/markdown_to_notion_converter.py,sha256=wTkH7o6367IWBtSqBrldpKx4rxHli176QfWtAenyysQ,15067
 notionary/page/notion_page.py,sha256=KIjVeiMJGWWxR6ty1uuNvMoQf2IoRmSUxwMdDIyOu40,17635
 notionary/page/notion_page_factory.py,sha256=UUEZ-cyEWL0OMVPrgjc4vJdcplEa1bO2yHCYooACYC8,8189
-notionary/page/notion_to_markdown_converter.py,sha256=RJn8JCcoAOGAhVtZGc4NL-puBnMAAm3udY9w-qIDMqo,8231
+notionary/page/notion_to_markdown_converter.py,sha256=WHrESgMZPqnp3kufi0YB7Cyy8U1rwhJ0d4HHdBRfRdU,8053
 notionary/page/content/notion_page_content_chunker.py,sha256=xRks74Dqec-De6-AVTxMPnXs-MSJBzSm1HfJfaHiKr8,3330
-notionary/page/content/page_content_manager.py,sha256=Z0zYWLzcoY0wijWhQT5KU8uxRnZZMJ7MgDKa4U5iBY4,3932
+notionary/page/content/page_content_manager.py,sha256=jXWscZyiFNLGMiuJ8Da9P26q_9Hit9_G1j0rVDlOc5M,6224
 notionary/page/metadata/metadata_editor.py,sha256=61uiw8oB25O8ePhytoJvZDetuof5sjPoM6aoHZGo4wc,4949
 notionary/page/metadata/notion_icon_manager.py,sha256=ixZrWsHGVpmF05Ncy9LCt8vZlKAQHYFZW-2yI5JZZDI,1426
 notionary/page/metadata/notion_page_cover_manager.py,sha256=qgQxQE-bx4oWjLFUQvpXD5GzO1Mx7w7htz1xC2BOqUg,1717
@@ -49,8 +49,8 @@ notionary/page/relations/relation_operation_result.py,sha256=NDxBzGntOxc_89ti-HG
 notionary/util/logging_mixin.py,sha256=fKsx9t90bwvL74ZX3dU-sXdC4TZCQyO6qU9I8txkw_U,1369
 notionary/util/page_id_utils.py,sha256=EYNMxgf-7ghzL5K8lKZBZfW7g5CsdY0Xuj4IYmU8RPk,1381
 notionary/util/singleton_decorator.py,sha256=GTNMfIlVNRUVMw_c88xqd12-DcqZJjmyidN54yqiNVw,472
-notionary-0.1.14.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
-notionary-0.1.14.dist-info/METADATA,sha256=aAgXmYYWBruH6azteEcg-N38clmDqszmgNVp3RWF0G0,6154
-notionary-0.1.14.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-notionary-0.1.14.dist-info/top_level.txt,sha256=fhONa6BMHQXqthx5PanWGbPL0b8rdFqhrJKVLf_adSs,10
-notionary-0.1.14.dist-info/RECORD,,
+notionary-0.1.15.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
+notionary-0.1.15.dist-info/METADATA,sha256=uXefq6BdsjQnMAf34az8oWfMb2_6L068evq_G8UGWlE,6154
+notionary-0.1.15.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+notionary-0.1.15.dist-info/top_level.txt,sha256=fhONa6BMHQXqthx5PanWGbPL0b8rdFqhrJKVLf_adSs,10
+notionary-0.1.15.dist-info/RECORD,,