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

notionary/page/notion_page_factory.py

@@ -0,0 +1,242 @@
+import logging
+from typing import List, Optional, Dict, Any
+from difflib import SequenceMatcher
+
+from notionary import NotionPage, NotionClient
+from notionary.util.logging_mixin import LoggingMixin
+from notionary.util.page_id_utils import format_uuid, extract_and_validate_page_id
+
+
+class NotionPageFactory(LoggingMixin):
+    """
+    Factory class for creating NotionPage instances.
+    Provides methods for creating page instances by page ID, URL, or name.
+    """
+
+    @classmethod
+    def class_logger(cls):
+        """Class logger - for class methods"""
+        return logging.getLogger(cls.__name__)
+
+    @classmethod
+    async def from_page_id(
+        cls, page_id: str, token: Optional[str] = None
+    ) -> NotionPage:
+        """
+        Create a NotionPage from a page ID.
+
+        Args:
+            page_id: The ID of the Notion page
+            token: Optional Notion API token (uses environment variable if not provided)
+
+        Returns:
+            An initialized NotionPage instance
+
+        Raises:
+            NotionError: If there is any error during page creation or connection
+        """
+        logger = cls.class_logger()
+
+        try:
+            formatted_id = format_uuid(page_id) or page_id
+
+            page = NotionPage(page_id=formatted_id, token=token)
+
+            logger.info("Successfully created page instance for ID: %s", formatted_id)
+            return page
+
+        except Exception as e:
+            error_msg = f"Error connecting to page {page_id}: {str(e)}"
+            logger.error(error_msg)
+
+    @classmethod
+    async def from_url(cls, url: str, token: Optional[str] = None) -> NotionPage:
+        """
+        Create a NotionPage from a Notion URL.
+
+        Args:
+            url: The URL of the Notion page
+            token: Optional Notion API token (uses environment variable if not provided)
+
+        Returns:
+            An initialized NotionPage instance
+
+        Raises:
+            NotionError: If there is any error during page creation or connection
+        """
+        logger = cls.class_logger()
+
+        try:
+            page_id = extract_and_validate_page_id(url=url)
+            if not page_id:
+                error_msg = f"Could not extract valid page ID from URL: {url}"
+                logger.error(error_msg)
+
+            page = NotionPage(page_id=page_id, url=url, token=token)
+
+            logger.info(
+                "Successfully created page instance from URL for ID: %s", page_id
+            )
+            return page
+
+        except Exception as e:
+            error_msg = f"Error connecting to page with URL {url}: {str(e)}"
+            logger.error(error_msg)
+
+    @classmethod
+    async def from_page_name(
+        cls, page_name: str, token: Optional[str] = None
+    ) -> NotionPage:
+        """
+        Create a NotionPage by finding a page with a matching name.
+        Uses fuzzy matching to find the closest match to the given name.
+        If no good match is found, suggests closest alternatives ("Did you mean?").
+
+        Args:
+            page_name: The name of the Notion page to search for
+            token: Optional Notion API token (uses environment variable if not provided)
+
+        Returns:
+            An initialized NotionPage instance
+
+        Raises:
+            NotionError: If there is any error during page search or connection
+            NotionPageNotFoundError: If no matching page found, includes suggestions
+        """
+        logger = cls.class_logger()
+        logger.debug("Searching for page with name: %s", page_name)
+
+        client = NotionClient(token=token)
+
+        try:
+            logger.debug("Using search endpoint to find pages")
+
+            search_payload = {
+                "filter": {"property": "object", "value": "page"},
+                "page_size": 100,
+            }
+
+            response = await client.post("search", search_payload)
+
+            if not response or "results" not in response:
+                error_msg = "Failed to fetch pages using search endpoint"
+                logger.error(error_msg)
+
+            pages = response.get("results", [])
+
+            if not pages:
+                error_msg = f"No pages found matching '{page_name}'"
+                logger.warning(error_msg)
+
+            logger.debug("Found %d pages, searching for best match", len(pages))
+
+            # Store all matches with their scores for potential suggestions
+            matches = []
+            best_match = None
+            best_score = 0
+
+            for page in pages:
+                title = cls._extract_title_from_page(page)
+                score = SequenceMatcher(None, page_name.lower(), title.lower()).ratio()
+
+                matches.append((page, title, score))
+
+                if score > best_score:
+                    best_score = score
+                    best_match = page
+
+            if best_score < 0.6 or not best_match:
+                # Sort matches by score in descending order
+                matches.sort(key=lambda x: x[2], reverse=True)
+
+                # Take top N suggestions (adjust as needed)
+                suggestions = [title for _, title, _ in matches[:5]]
+
+                error_msg = f"No good match found for '{page_name}'. Did you mean one of these?\n"
+                error_msg += "\n".join(f"- {suggestion}" for suggestion in suggestions)
+
+                logger.warning(
+                    "No good match found for '%s'. Best score: %.2f",
+                    page_name,
+                    best_score,
+                )
+
+            page_id = best_match.get("id")
+
+            if not page_id:
+                error_msg = "Best match page has no ID"
+                logger.error(error_msg)
+
+            matched_name = cls._extract_title_from_page(best_match)
+
+            logger.info(
+                "Found matching page: '%s' (ID: %s) with score: %.2f",
+                matched_name,
+                page_id,
+                best_score,
+            )
+
+            page = NotionPage(page_id=page_id, title=matched_name, token=token)
+
+            logger.info("Successfully created page instance for '%s'", matched_name)
+            await client.close()
+            return page
+
+        except Exception as e:
+            error_msg = f"Error finding page by name: {str(e)}"
+            logger.error(error_msg)
+
+    @classmethod
+    def _extract_title_from_page(cls, page: Dict[str, Any]) -> str:
+        """
+        Extract the title from a page object.
+
+        Args:
+            page: The page object returned from the Notion API
+
+        Returns:
+            The title of the page
+
+        Raises:
+            NotionError: If the title cannot be extracted
+        """
+        try:
+            if "properties" in page:
+                for prop_value in page["properties"].values():
+                    if prop_value.get("type") != "title":
+                        continue
+                    title_array = prop_value.get("title", [])
+                    if not title_array:
+                        continue
+                    return cls._extract_text_from_rich_text(title_array)
+
+            if "child_page" in page:
+                return page.get("child_page", {}).get("title", "Untitled")
+
+            return "Untitled"
+
+        except Exception as e:
+            error_msg = f"Error extracting page title: {str(e)}"
+            cls.class_logger().warning(error_msg)
+            return "Untitled"
+
+    @classmethod
+    def _extract_text_from_rich_text(cls, rich_text: List[Dict[str, Any]]) -> str:
+        """
+        Extract plain text from a rich text array.
+
+        Args:
+            rich_text: A list of rich text objects from the Notion API
+
+        Returns:
+            The combined plain text content
+        """
+        if not rich_text:
+            return ""
+
+        text_parts = []
+        for text_obj in rich_text:
+            if "plain_text" in text_obj:
+                text_parts.append(text_obj["plain_text"])
+
+        return "".join(text_parts)

notionary/page/notion_to_markdown_converter.py

@@ -0,0 +1,245 @@
+from typing import Dict, Any, List, Optional
+
+from notionary.elements.block_element_registry import (
+    BlockElementRegistry,
+)
+from notionary.elements.block_element_registry_builder import (
+    BlockElementRegistryBuilder,
+)
+
+
+class NotionToMarkdownConverter:
+    """Converts Notion blocks to Markdown text with support for nested structures."""
+
+    def __init__(self, block_registry: Optional[BlockElementRegistry] = None):
+        """
+        Initialize the NotionToMarkdownConverter.
+
+        Args:
+            block_registry: Optional registry of Notion block elements
+        """
+        self._block_registry = (
+            block_registry or BlockElementRegistryBuilder().create_standard_registry()
+        )
+
+    def convert(self, blocks: List[Dict[str, Any]]) -> str:
+        """
+        Convert Notion blocks to Markdown text, handling nested structures.
+
+        Args:
+            blocks: List of Notion blocks
+
+        Returns:
+            Markdown text
+        """
+        if not blocks:
+            return ""
+
+        markdown_parts = []
+
+        for block in blocks:
+            block_markdown = self._convert_single_block_with_children(block)
+            if block_markdown:
+                markdown_parts.append(block_markdown)
+
+        return "\n\n".join(filter(None, markdown_parts))
+
+    def _convert_single_block_with_children(self, block: Dict[str, Any]) -> str:
+        """
+        Process a single block, including any children.
+
+        Args:
+            block: Notion block to process
+
+        Returns:
+            Markdown representation of the block and its children
+        """
+        if not block:
+            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)
+        
+        if block_type in ["column_list", "column"]:
+            return 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:
+        """
+        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:
+        """
+        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:
+        """
+        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
+        """
+        return f"{block_markdown}\n\n{children_markdown}"
+
+    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
+        """
+        indent = " " * spaces
+        return "\n".join([f"{indent}{line}" for line in text.split("\n")])
+
+    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:
+        """
+        Recursively extract toggle content from a block and its children.
+        
+        Args:
+            block: Block to process
+            result: List to collect toggle content
+        """
+        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)
+
+    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:
+        """
+        Add toggle header text to result list.
+        
+        Args:
+            block: Toggle block
+            result: List to add header to
+        """
+        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:
+        """
+        Add formatted toggle children to result list.
+        
+        Args:
+            block: Toggle block with children
+            result: List to add children content to
+        """
+        for child in block.get("children", []):
+            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])

notionary/{core/page → page}/properites/database_property_service.py

@@ -1,5 +1,5 @@
 from typing import Dict, List, Optional, Any, Tuple
-from notionary.core.notion_client import NotionClient
+from notionary.notion_client import NotionClient
 from notionary.util.logging_mixin import LoggingMixin
 
 

notionary/{core/page → page}/properites/page_property_manager.py

@@ -1,17 +1,17 @@
 from typing import Dict, Any, List, Optional
-from notionary.core.notion_client import NotionClient
-from notionary.core.page.metadata.metadata_editor import MetadataEditor
-from notionary.core.page.properites.property_operation_result import (
+from notionary.notion_client import NotionClient
+from notionary.page.metadata.metadata_editor import MetadataEditor
+from notionary.page.properites.property_operation_result import (
     PropertyOperationResult,
 )
-from notionary.core.page.relations.notion_page_title_resolver import (
+from notionary.page.relations.notion_page_title_resolver import (
     NotionPageTitleResolver,
 )
-from notionary.core.page.properites.database_property_service import (
+from notionary.page.properites.database_property_service import (
     DatabasePropertyService,
 )
-from notionary.core.page.relations.page_database_relation import PageDatabaseRelation
-from notionary.core.page.properites.property_value_extractor import (
+from notionary.page.relations.page_database_relation import PageDatabaseRelation
+from notionary.page.properites.property_value_extractor import (
     PropertyValueExtractor,
 )
 from notionary.util.logging_mixin import LoggingMixin

notionary/{core/page → page}/relations/notion_page_relation_manager.py

@@ -1,9 +1,9 @@
 from typing import Any, Dict, List, Optional
-from notionary.core.notion_client import NotionClient
-from notionary.core.page.relations.notion_page_title_resolver import (
+from notionary.notion_client import NotionClient
+from notionary.page.relations.notion_page_title_resolver import (
     NotionPageTitleResolver,
 )
-from notionary.core.page.relations.relation_operation_result import (
+from notionary.page.relations.relation_operation_result import (
     RelationOperationResult,
 )
 from notionary.util.logging_mixin import LoggingMixin

notionary/{core/page → page}/relations/notion_page_title_resolver.py

@@ -1,5 +1,5 @@
 from typing import Optional
-from notionary.core.notion_client import NotionClient
+from notionary.notion_client import NotionClient
 from notionary.util.logging_mixin import LoggingMixin
 
 

notionary/{core/page → page}/relations/page_database_relation.py

@@ -1,5 +1,5 @@
 from typing import Dict, Optional, Any
-from notionary.core.notion_client import NotionClient
+from notionary.notion_client import NotionClient
 from notionary.util.logging_mixin import LoggingMixin
 
 

notionary/util/page_id_utils.py

@@ -27,7 +27,9 @@ def format_uuid(value: str) -> Optional[str]:
     return extract_uuid(value)
 
 
-def extract_and_validate_page_id(page_id: Optional[str], url: Optional[str]) -> str:
+def extract_and_validate_page_id(
+    page_id: Optional[str] = None, url: Optional[str] = None
+) -> str:
     if not page_id and not url:
         raise ValueError("Either page_id or url must be provided")
 

{notionary-0.1.12.dist-info → notionary-0.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionary
-Version: 0.1.12
+Version: 0.1.14
 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/RECORD

@@ -0,0 +1,56 @@
+notionary/__init__.py,sha256=sVqdwzMQcc9jf6FKi1qflilsx8rnWzluVhWewVi5gyI,717
+notionary/notion_client.py,sha256=gRyTBVuCZCQod6L18VxzKl38Tn5oXdE0gPl7yGG8anQ,4446
+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
+notionary/database/notion_database_factory.py,sha256=Af57yaUHidD8TKJ8uyXOc2nnqHm7on6VGFdDRjxiq9o,6692
+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/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
+notionary/elements/column_element.py,sha256=F_hnaBtQbnfRiKRVfpo9X5aNiw75SxeHfWOiMyMPcBw,10706
+notionary/elements/divider_element.py,sha256=RCN87xFizAjKd8c_beywNW5lfXFFtOZPT8tyXgAh2D0,2776
+notionary/elements/embed_element.py,sha256=LZjbSfwq0v8NGzwfUXpnGwvJ34IjYDwZzqyxVd2Iqt8,4768
+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/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
+notionary/elements/table_element.py,sha256=jCq1ZFNCdxYEI6ER21OZ64TYGjW162gH-A6DUbldxY4,11222
+notionary/elements/text_inline_formatter.py,sha256=FE_Sq2cozpu5RVtMbnPq21gD06UjH3LMRYr3s16JKYo,10606
+notionary/elements/todo_lists.py,sha256=PrLZdp1-q1gx7mBsL6NUQ5U18HxmkUw8yqVh9qJpArE,4233
+notionary/elements/toggle_element.py,sha256=5cyWjkBgJcKdhhdrOn4bEM8Dpc5gXWhVbM4qZm9FNYM,7242
+notionary/elements/video_element.py,sha256=uYCwFakna7pzpCDjjtxRhUkSkPfzJTttdKUKYSluqyw,6031
+notionary/exceptions/database_exceptions.py,sha256=I-Tx6bYRLpi5pjGPtbT-Mqxvz3BFgYTiuZxknJeLxtI,2638
+notionary/exceptions/page_creation_exception.py,sha256=4v7IuZD6GsQLrqhDLriGjuG3ML638gAO53zDCrLePuU,281
+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/content/notion_page_content_chunker.py,sha256=xRks74Dqec-De6-AVTxMPnXs-MSJBzSm1HfJfaHiKr8,3330
+notionary/page/content/page_content_manager.py,sha256=Z0zYWLzcoY0wijWhQT5KU8uxRnZZMJ7MgDKa4U5iBY4,3932
+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
+notionary/page/properites/database_property_service.py,sha256=AJuBGahbb53VQa6IGGHxBMoOgCy6vFZg08uR_eDjNUs,11570
+notionary/page/properites/page_property_manager.py,sha256=Xl8Cwn8WVszqpFXT_NvASkmP5igpCTEgRVhG_F45424,6914
+notionary/page/properites/property_formatter.py,sha256=d_Nr5XQxgjB6VIS0u3ey14MOUKY416o_BvdXjbkUNAQ,3667
+notionary/page/properites/property_operation_result.py,sha256=PhxHJJxxG2BdDl7aswhWnMSmf9RQtoinKkRHDoqxwCs,3913
+notionary/page/properites/property_value_extractor.py,sha256=1BfyCYrFzfIUmNTozavrLTjG--6P6Dy2tkewf6rHHwQ,2353
+notionary/page/relations/notion_page_relation_manager.py,sha256=D7JZJLXjX2Jn3CIseJxoMK9qL9gp88t4NmL9Ihu06eg,12682
+notionary/page/relations/notion_page_title_resolver.py,sha256=jUYsEkfyDgdh77oh2awYEB5g1vQqLBq6xYSXL-4uPH8,1722
+notionary/page/relations/page_database_relation.py,sha256=F9aGXFjjL8ZLNbfTGeGm_QAyXhz2AEOw7GgDLdprEcE,2313
+notionary/page/relations/relation_operation_result.py,sha256=NDxBzGntOxc_89ti-HG8xDSqfY6PwyGHKHrrKbCzNjM,5010
+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/core/converters/__init__.py

@@ -1,50 +0,0 @@
-# Import converters
-from .markdown_to_notion_converter import MarkdownToNotionConverter
-from .notion_to_markdown_converter import NotionToMarkdownConverter
-
-# Import registry classes
-from .registry.block_element_registry import BlockElementRegistry
-from .registry.block_element_registry_builder import BlockElementRegistryBuilder
-
-# Import elements for type hints and direct use
-from .elements.paragraph_element import ParagraphElement
-from .elements.heading_element import HeadingElement
-from .elements.callout_element import CalloutElement
-from .elements.code_block_element import CodeBlockElement
-from .elements.divider_element import DividerElement
-from .elements.table_element import TableElement
-from .elements.todo_lists import TodoElement
-from .elements.list_element import BulletedListElement, NumberedListElement
-from .elements.qoute_element import QuoteElement
-from .elements.image_element import ImageElement
-from .elements.video_element import VideoElement
-from .elements.toggle_element import ToggleElement
-from .elements.bookmark_element import BookmarkElement
-from .elements.column_element import ColumnElement
-
-default_registry = BlockElementRegistryBuilder.create_standard_registry()
-
-# Define what to export
-__all__ = [
-    "BlockElementRegistry",
-    "BlockElementRegistryBuilder",
-    "MarkdownToNotionConverter",
-    "NotionToMarkdownConverter",
-    "default_registry",
-    # Element classes
-    "ParagraphElement",
-    "HeadingElement",
-    "CalloutElement",
-    "CodeBlockElement",
-    "DividerElement",
-    "TableElement",
-    "TodoElement",
-    "QuoteElement",
-    "BulletedListElement",
-    "NumberedListElement",
-    "ImageElement",
-    "VideoElement",
-    "ToggleElement",
-    "BookmarkElement",
-    "ColumnElement",
-]