notionary 0.1.19__py3-none-any.whl → 0.1.21__py3-none-any.whl

notionary/elements/block_element_registry.py

@@ -1,233 +0,0 @@
-from typing import Dict, Any, Optional, List, Type
-
-from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.elements.text_inline_formatter import TextInlineFormatter
-
-
-class BlockElementRegistry:
-    """Registry of elements that can convert between Markdown and Notion."""
-
-    def __init__(self, elements=None):
-        """
-        Initialize a new registry instance.
-
-        Args:
-            elements: Optional list of NotionBlockElement classes to register at creation
-        """
-        self._elements = []
-
-        # Register initial elements if provided
-        if elements:
-            for element in elements:
-                self.register(element)
-
-    def register(self, element_class: Type[NotionBlockElement]):
-        """Register an element class."""
-        self._elements.append(element_class)
-        return self
-
-    def deregister(self, element_class: Type[NotionBlockElement]) -> bool:
-        """
-        Deregister an element class.
-
-        Args:
-            element_class: The element class to remove from the registry
-
-        Returns:
-            bool: True if the element was removed, False if it wasn't in the registry
-        """
-        if element_class in self._elements:
-            self._elements.remove(element_class)
-            return True
-        return False
-
-    def clear(self):
-        """Clear the registry completely."""
-        self._elements.clear()
-        return self
-
-    def find_markdown_handler(self, text: str) -> Optional[Type[NotionBlockElement]]:
-        """Find an element that can handle the given markdown text."""
-        for element in self._elements:
-            if element.match_markdown(text):
-                return element
-        return None
-
-    def find_notion_handler(
-        self, block: Dict[str, Any]
-    ) -> Optional[Type[NotionBlockElement]]:
-        """Find an element that can handle the given Notion block."""
-        for element in self._elements:
-            if element.match_notion(block):
-                return element
-        return None
-
-    def markdown_to_notion(self, text: str) -> Optional[Dict[str, Any]]:
-        """Convert markdown to Notion block using registered elements."""
-        handler = self.find_markdown_handler(text)
-        if handler:
-            return handler.markdown_to_notion(text)
-        return None
-
-    def notion_to_markdown(self, block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion block to markdown using registered elements."""
-        handler = self.find_notion_handler(block)
-        if handler:
-            return handler.notion_to_markdown(block)
-        return None
-
-    def get_multiline_elements(self) -> List[Type[NotionBlockElement]]:
-        """Get all registered multiline elements."""
-        return [element for element in self._elements if element.is_multiline()]
-
-    def get_elements(self) -> List[Type[NotionBlockElement]]:
-        """Get all registered elements."""
-        return self._elements.copy()
-
-    def generate_llm_prompt(self) -> str:
-        """
-        Generates an LLM system prompt that describes the Markdown syntax of all registered elements.
-
-        TextInlineFormatter is automatically added if not already registered.
-
-        Returns:
-            A complete system prompt for an LLM that should understand Notion-Markdown syntax
-        """
-        # Create a copy of registered elements
-        element_classes = self._elements.copy()
-
-        formatter_names = [e.__name__ for e in element_classes]
-        if "TextInlineFormatter" not in formatter_names:
-            element_classes = [TextInlineFormatter] + element_classes
-
-        return MarkdownSyntaxPromptBuilder.generate_system_prompt(element_classes)
-
-
-class MarkdownSyntaxPromptBuilder:
-    """
-    Generator for LLM system prompts that describe Notion-Markdown syntax.
-
-    This class extracts information about supported Markdown patterns
-    and formats them optimally for LLMs.
-    """
-
-    # Standard system prompt template
-    SYSTEM_PROMPT_TEMPLATE = """You are a knowledgeable assistant that helps users create content for Notion pages.
-Notion supports standard Markdown with some special extensions for creating rich content.
-
-{element_docs}
-
-Important usage guidelines:
-
-1. The backtick code fence syntax (```) should ONLY be used when creating actual code blocks or diagrams.
-Do not wrap examples or regular content in backticks unless you're showing code.
-
-2. Use inline formatting (bold, italic, highlights, etc.) across all content to enhance readability.
-The highlight syntax (==text== and ==color:text==) is especially useful for emphasizing important points.
-
-3. Notion's extensions to Markdown (like callouts, bookmarks, toggles) provide richer formatting options
-than standard Markdown while maintaining the familiar Markdown syntax for basic elements.
-
-4. You can use these Markdown extensions alongside standard Markdown to create visually appealing
-and well-structured content.
-
-5. Remember that features like highlighting with ==yellow:important== work in all text blocks including
-paragraphs, lists, quotes, etc.
-"""
-
-    @staticmethod
-    def generate_element_doc(element_class: Type[NotionBlockElement]) -> str:
-        """
-        Generates documentation for a specific NotionBlockElement.
-
-        Uses the element's get_llm_prompt_content method if available.
-        """
-        class_name = element_class.__name__
-        element_name = class_name.replace("Element", "")
-
-        # Start with element name as header
-        result = [f"## {element_name}"]
-
-        # Use get_llm_prompt_content if available
-        if hasattr(element_class, "get_llm_prompt_content") and callable(
-            getattr(element_class, "get_llm_prompt_content")
-        ):
-            content = element_class.get_llm_prompt_content()
-
-            if content.get("description"):
-                result.append(content["description"])
-
-            if content.get("syntax"):
-                result.append("\n### Syntax:")
-                for syntax_item in content["syntax"]:
-                    result.append(f"{syntax_item}")
-
-            if content.get("examples"):
-                result.append("\n### Examples:")
-                for example in content["examples"]:
-                    result.append(example)
-
-            # Add any additional custom sections
-            for key, value in content.items():
-                if key not in ["description", "syntax", "examples"] and isinstance(
-                    value, str
-                ):
-                    result.append(f"\n### {key.replace('_', ' ').title()}:")
-                    result.append(value)
-
-        return "\n".join(result)
-
-    @classmethod
-    def generate_element_docs(
-        cls,
-        element_classes: List[Type[NotionBlockElement]],
-    ) -> str:
-        """
-        Generates complete documentation for all provided element classes.
-
-        Args:
-            element_classes: List of NotionBlockElement classes
-
-        Returns:
-            Documentation text for all elements
-        """
-        docs = [
-            "# Custom Markdown Syntax for Notion Blocks",
-            "The following custom Markdown patterns are supported for creating Notion blocks:",
-        ]
-
-        text_formatter = None
-        other_elements = []
-
-        for element in element_classes:
-            if element.__name__ == "TextInlineFormatter":
-                text_formatter = element
-            else:
-                other_elements.append(element)
-
-        if text_formatter:
-            docs.append("\n" + cls.generate_element_doc(text_formatter))
-
-        for element in other_elements:
-            if element.__name__ != "InlineFormattingElement":
-                docs.append("\n" + cls.generate_element_doc(element))
-
-        return "\n".join(docs)
-
-    @classmethod
-    def generate_system_prompt(
-        cls,
-        element_classes: List[Type[NotionBlockElement]],
-    ) -> str:
-        """
-        Generates a complete system prompt for LLMs.
-
-        Args:
-            element_classes: List of element classes to document
-
-        Returns:
-            Complete system prompt for an LLM
-        """
-        element_docs = cls.generate_element_docs(element_classes)
-
-        return cls.SYSTEM_PROMPT_TEMPLATE.format(element_docs=element_docs)

notionary/elements/list_element.py

@@ -1,130 +0,0 @@
-import re
-from typing import Dict, Any, Optional
-from typing_extensions import override
-from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.elements.text_inline_formatter import TextInlineFormatter
-
-
-class BulletedListElement(NotionBlockElement):
-    """Class for converting between Markdown bullet lists and Notion bulleted list items."""
-
-    @override
-    @staticmethod
-    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
-        """Convert markdown bulleted list item to Notion block."""
-        pattern = re.compile(
-            r"^(\s*)[*\-+]\s+(?!\[[ x]\])(.+)$"
-        )  # Avoid matching todo items
-        list_match = pattern.match(text)
-        if not list_match:
-            return None
-
-        content = list_match.group(2)
-
-        # Use parse_inline_formatting to handle rich text
-        rich_text = TextInlineFormatter.parse_inline_formatting(content)
-
-        return {
-            "type": "bulleted_list_item",
-            "bulleted_list_item": {"rich_text": rich_text, "color": "default"},
-        }
-
-    @override
-    @staticmethod
-    def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion bulleted list item block to markdown."""
-        if block.get("type") != "bulleted_list_item":
-            return None
-
-        rich_text = block.get("bulleted_list_item", {}).get("rich_text", [])
-        content = TextInlineFormatter.extract_text_with_formatting(rich_text)
-
-        return f"- {content}"
-
-    @override
-    @staticmethod
-    def match_markdown(text: str) -> bool:
-        """Check if this element can handle the given markdown text."""
-        pattern = re.compile(r"^(\s*)[*\-+]\s+(?!\[[ x]\])(.+)$")
-        return bool(pattern.match(text))
-
-    @override
-    @staticmethod
-    def match_notion(block: Dict[str, Any]) -> bool:
-        """Check if this element can handle the given Notion block."""
-        return block.get("type") == "bulleted_list_item"
-
-    @override
-    @classmethod
-    def get_llm_prompt_content(cls) -> dict:
-        """Returns information for LLM prompts about this element."""
-        return {
-            "description": "Creates bulleted list items for unordered lists.",
-            "when_to_use": "Use for lists where order doesn't matter, such as features, options, or items without hierarchy.",
-            "syntax": ["- Item text", "* Item text", "+ Item text"],
-            "examples": ["- First item\n- Second item\n- Third item"],
-        }
-
-
-class NumberedListElement:
-    """Class for converting between Markdown numbered lists and Notion numbered list items."""
-
-    @override
-    @staticmethod
-    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
-        """Convert markdown numbered list item to Notion block."""
-        pattern = re.compile(r"^\s*(\d+)\.\s+(.+)$")
-        numbered_match = pattern.match(text)
-        if not numbered_match:
-            return None
-
-        content = numbered_match.group(2)
-
-        # Use parse_inline_formatting to handle rich text
-        rich_text = TextInlineFormatter.parse_inline_formatting(content)
-
-        return {
-            "type": "numbered_list_item",
-            "numbered_list_item": {"rich_text": rich_text, "color": "default"},
-        }
-
-    @override
-    @staticmethod
-    def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion numbered list item block to markdown."""
-        if block.get("type") != "numbered_list_item":
-            return None
-
-        rich_text = block.get("numbered_list_item", {}).get("rich_text", [])
-        content = TextInlineFormatter.extract_text_with_formatting(rich_text)
-
-        return f"1. {content}"
-
-    @override
-    @staticmethod
-    def match_markdown(text: str) -> bool:
-        """Check if this element can handle the given markdown text."""
-        pattern = re.compile(r"^\s*\d+\.\s+(.+)$")
-        return bool(pattern.match(text))
-
-    @override
-    @staticmethod
-    def match_notion(block: Dict[str, Any]) -> bool:
-        """Check if this element can handle the given Notion block."""
-        return block.get("type") == "numbered_list_item"
-
-    @override
-    @staticmethod
-    def is_multiline() -> bool:
-        return False
-
-    @override
-    @classmethod
-    def get_llm_prompt_content(cls) -> dict:
-        """Returns information for LLM prompts about this element."""
-        return {
-            "description": "Creates numbered list items for ordered sequences.",
-            "when_to_use": "Use for lists where order matters, such as steps, rankings, or sequential items.",
-            "syntax": ["1. Item text"],
-            "examples": ["1. First step\n2. Second step\n3. Third step"],
-        }

notionary/util/singleton_decorator.py

@@ -1,20 +0,0 @@
-from typing import TypeVar
-from functools import wraps
-
-T = TypeVar("T")
-
-
-def singleton(cls: T) -> T:
-    """
-    Decorator zur Implementierung des Singleton-Musters.
-    Stellt sicher, dass nur eine Instanz der Klasse existiert.
-    """
-    instances = {}
-
-    @wraps(cls)
-    def get_instance(*args, **kwargs):
-        if cls not in instances:
-            instances[cls] = cls(*args, **kwargs)
-        return instances[cls]
-
-    return get_instance

notionary-0.1.19.dist-info/RECORD

@@ -1,56 +0,0 @@
-notionary/__init__.py,sha256=sVqdwzMQcc9jf6FKi1qflilsx8rnWzluVhWewVi5gyI,717
-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=Zm5Ev0n4idKUe3ms8l3B4fyIezNNCCEDWHZ5vDoTknQ,7985
-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=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
-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=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
-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=WHrESgMZPqnp3kufi0YB7Cyy8U1rwhJ0d4HHdBRfRdU,8053
-notionary/page/content/notion_page_content_chunker.py,sha256=xRks74Dqec-De6-AVTxMPnXs-MSJBzSm1HfJfaHiKr8,3330
-notionary/page/content/page_content_manager.py,sha256=JM4ga-Y6k6mTbyH9YGYWbdrxpSLAdmZa845EwFyADMg,6142
-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=xyV92IFjFbizqDLV9UK89JVyDAtxBLZqVDId-orRP0A,13128
-notionary/page/relations/notion_page_title_resolver.py,sha256=1751DKRI0o586-78fRDWEtfWyQViMir_08v7YpetxfY,3016
-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.19.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
-notionary-0.1.19.dist-info/METADATA,sha256=Ws3WI2Yp4HopH7_Jo4eQbzSN0ziOHZOaqieDNZK9kSM,8350
-notionary-0.1.19.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-notionary-0.1.19.dist-info/top_level.txt,sha256=fhONa6BMHQXqthx5PanWGbPL0b8rdFqhrJKVLf_adSs,10
-notionary-0.1.19.dist-info/RECORD,,