notionary 0.1.29__py3-none-any.whl → 0.2.0__py3-none-any.whl

notionary/{elements/prompts → prompting}/element_prompt_content.py

@@ -24,14 +24,19 @@ class ElementPromptContent:
     avoid: Optional[str] = None
     """Optional field listing scenarios when this element should be avoided."""
 
+    is_standard_markdown: bool = False
+    """Indicates whether this element follows standard Markdown syntax (and does not require full examples)."""
+
     def __post_init__(self):
         """Validates that the content meets minimum requirements."""
         if not self.description:
             raise ValueError("Description is required")
         if not self.syntax:
             raise ValueError("Syntax is required")
-        if not self.examples:
-            raise ValueError("At least one example is required")
+        if not self.examples and not self.is_standard_markdown:
+            raise ValueError(
+                "At least one example is required unless it's standard markdown."
+            )
         if not self.when_to_use:
             raise ValueError("Usage guidelines are required")
 
@@ -48,6 +53,7 @@ class ElementPromptBuilder:
         self._examples: List[str] = []
         self._when_to_use: Optional[str] = None
         self._avoid: Optional[str] = None
+        self._is_standard_markdown = False
 
     def with_description(self, description: str) -> Self:
         """Set the description of the element."""
@@ -79,6 +85,12 @@ class ElementPromptBuilder:
         self._avoid = avoid
         return self
 
+    def with_standard_markdown(self) -> Self:
+        """Indicate that this element follows standard Markdown syntax."""
+        self._examples = []
+        self._is_standard_markdown = True
+        return self
+
     def build(self) -> ElementPromptContent:
         """
         Build and validate the ElementPromptContent object.
@@ -93,8 +105,10 @@ class ElementPromptBuilder:
             raise ValueError("Description is required")
         if not self._syntax:
             raise ValueError("Syntax is required")
-        if not self._examples:
-            raise ValueError("At least one example is required")
+        if not self._examples and not self._is_standard_markdown:
+            raise ValueError(
+                "At least one example is required unless it's standard markdown."
+            )
         if not self._when_to_use:
             raise ValueError("Usage guidelines are required")
 
@@ -104,4 +118,5 @@ class ElementPromptBuilder:
             examples=self._examples,
             when_to_use=self._when_to_use,
             avoid=self._avoid,
+            is_standard_markdown=self._is_standard_markdown,
         )

notionary/prompting/markdown_syntax_prompt_generator.py

@@ -0,0 +1,92 @@
+import os
+from pathlib import Path
+from typing import Type, List
+from notionary.elements.notion_block_element import NotionBlockElement
+
+
+class MarkdownSyntaxPromptGenerator:
+    """
+    Generator for LLM system prompts that describe Notion-Markdown syntax.
+
+    This class extracts information about supported Markdown patterns
+    and formats them optimally for LLMs.
+    """
+
+    def __init__(self):
+        # Lade das Template aus der Markdown-Datei
+        self.SYSTEM_PROMPT_TEMPLATE = self._load_template()
+
+    def _load_template(self) -> str:
+        """
+        Lädt das Prompt-Template aus der Markdown-Datei.
+        """
+        current_dir = Path(__file__).parent
+        template_path = current_dir /  "res/notion_syntax_prompt.md"
+
+        try:
+            with open(template_path, "r", encoding="utf-8") as file:
+                return file.read()
+        except FileNotFoundError:
+            raise FileNotFoundError(f"Template file not found at {template_path}")
+        except Exception as e:
+            raise RuntimeError(f"Error loading template file: {e}")
+
+    @staticmethod
+    def generate_element_doc(element_class: Type[NotionBlockElement]) -> str:
+        """
+        Generates documentation for a specific NotionBlockElement in a compact format.
+        Uses the element's get_llm_prompt_content method if available.
+        """
+        class_name = element_class.__name__
+        element_name = class_name.replace("Element", "")
+
+        content = element_class.get_llm_prompt_content()
+
+        doc_parts = [
+            f"## {element_name}",
+            f"{content.description}",
+            f"**Syntax:** {content.syntax}",
+        ]
+
+        if content.examples:
+            doc_parts.append("**Examples:**")
+            for example in content.examples:
+                doc_parts.append(example)
+
+        doc_parts.append(f"**When to use:** {content.when_to_use}")
+
+        if content.avoid:
+            doc_parts.append(f"**Avoid:** {content.avoid}")
+
+        return "\n".join([part for part in doc_parts if part])
+
+    @classmethod
+    def generate_element_docs(
+        cls, element_classes: List[Type[NotionBlockElement]]
+    ) -> str:
+        """
+        Generates complete documentation for all provided element classes.
+        """
+        docs = [
+            "# Markdown Syntax for Notion Blocks",
+            "The following Markdown patterns are supported for creating Notion blocks:",
+        ]
+
+        # Generate docs for each element
+        for element in element_classes:
+            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.
+        """
+        # Erstelle eine Instanz, um das Template zu laden
+        instance = cls()
+        element_docs = cls.generate_element_docs(element_classes)
+        return instance.SYSTEM_PROMPT_TEMPLATE.format(element_docs=element_docs)

notionary/util/logging_mixin.py

@@ -1,5 +1,6 @@
 import logging
 import inspect
+from typing import Optional, ClassVar
 
 
 def setup_logging():
@@ -10,19 +11,27 @@ def setup_logging():
 
 
 class LoggingMixin:
+    # Class attribute with proper typing
+    logger: ClassVar[logging.Logger] = None
+
+    def __init_subclass__(cls, **kwargs):
+        """
+        This method is called when a class inherits from LoggingMixin.
+        It automatically sets up the logger as a class attribute.
+        """
+        super().__init_subclass__(**kwargs)
+        cls.logger = logging.getLogger(cls.__name__)
+
     @property
-    def logger(self):
+    def instance_logger(self) -> logging.Logger:
+        """Instance logger - for instance methods"""
         if not hasattr(self, "_logger"):
             self._logger = logging.getLogger(self.__class__.__name__)
         return self._logger
 
-    @classmethod
-    def class_logger(cls):
-        """Class logger - für Klassenmethoden"""
-        return logging.getLogger(cls.__name__)
-
     @staticmethod
-    def static_logger():
+    def static_logger() -> logging.Logger:
+        """Static logger - for static methods"""
         stack = inspect.stack()
         for frame_info in stack[1:]:
             class_name = LoggingMixin._get_class_name_from_frame(frame_info.frame)
@@ -31,7 +40,7 @@ class LoggingMixin:
         return logging.getLogger("UnknownStaticContext")
 
     @staticmethod
-    def _get_class_name_from_frame(frame):
+    def _get_class_name_from_frame(frame) -> Optional[str]:
         local_vars = frame.f_locals
         if "self" in local_vars:
             return local_vars["self"].__class__.__name__

notionary/util/warn_direct_constructor_usage.py

@@ -0,0 +1,54 @@
+import functools
+import inspect
+from typing import Callable, Any, TypeVar, cast
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def warn_direct_constructor_usage(func: F) -> F:
+    """
+    Method decorator that logs a warning when the constructor is called directly
+    instead of through a factory method.
+
+    This is an advisory decorator - it only logs a warning and doesn't
+    prevent direct constructor usage.
+    """
+
+    @functools.wraps(func)
+    def wrapper(self, *args, **kwargs):
+        # Get the call stack
+        stack = inspect.stack()
+
+        self._from_factory = False
+
+        search_depth = min(6, len(stack))
+
+        for i in range(1, search_depth):
+            if i >= len(stack):
+                break
+
+            caller_frame = stack[i]
+            caller_name = caller_frame.function
+
+            # Debug logging might be helpful during development
+            # print(f"Frame {i}: {caller_name}")
+
+            # If called from a factory method, mark it and break
+            if caller_name.startswith("create_from_") or caller_name.startswith(
+                "from_"
+            ):
+                self._from_factory = True
+                break
+
+        # If not from factory, log warning
+        if not self._from_factory and hasattr(self, "logger"):
+            self.logger.warning(
+                "Advisory: Direct constructor usage is discouraged. "
+                "Consider using factory methods like create_from_page_id(), "
+                "create_from_url(), or create_from_page_name() instead."
+            )
+
+        # Call the original __init__
+        return func(self, *args, **kwargs)
+
+    return cast(F, wrapper)

{notionary-0.1.29.dist-info → notionary-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionary
-Version: 0.1.29
+Version: 0.2.0
 Summary: A toolkit to convert between Markdown and Notion blocks
 Home-page: https://github.com/mathisarends/notionary
 Author: Mathis Arends
@@ -12,6 +12,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.28.0
 Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: pydantic>=2.11.4
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

notionary-0.2.0.dist-info/RECORD

@@ -0,0 +1,60 @@
+notionary/__init__.py,sha256=hPvZ-iqt5R_dAs9KaRBhC5eXzuQ5uvt-9EaU2O_7bZw,691
+notionary/notion_client.py,sha256=sJJMB36DqL0abcG-5w_plUDeS-zn1x0LpCgVNYeKqx0,7413
+notionary/database/database_discovery.py,sha256=qDGFhXG9s-_6CXdRg8tMiwX4dvX7jLjgAUFPSNlYtlI,4506
+notionary/database/notion_database.py,sha256=zbHPejETr101pprd7kewZ555d_TONN_wJi7b9Eyfoyg,7634
+notionary/database/notion_database_factory.py,sha256=FmijGYz6A4mCWVionOg9sxgFXfb9he52xdgNswJw24k,6584
+notionary/database/models/page_result.py,sha256=Vmm5_oYpYAkIIJVoTd1ZZGloeC3cmFLMYP255mAmtaw,233
+notionary/elements/audio_element.py,sha256=7bEpFl9jA6S1UZlEXsmFzEUVoViEp1o_7zZIC-S7750,5345
+notionary/elements/bookmark_element.py,sha256=msCtZvuPkIj1kiShNwE8i1GDYwamFb5mwRyZm4XyVY4,8145
+notionary/elements/bulleted_list_element.py,sha256=obsb3JqUNET3uS5OZM3yzDqxSzJzUuEob-Fzx0UIg9Y,2664
+notionary/elements/callout_element.py,sha256=ZsRvRtVy9kxdTwgrB5JGjZ4qcCiwcC0WimWJ_cW0aLY,4492
+notionary/elements/code_block_element.py,sha256=IbwpptMLtHDFO0Hyvt2o0p5AZ0S4vhxfzoBhTqKexSY,6240
+notionary/elements/divider_element.py,sha256=0e10YK-CC8uGuL7921dEIjeJK9ha-WhRIYRf2fFuxVQ,2211
+notionary/elements/embed_element.py,sha256=Zcc18Kl8SGoG98P2aYE0TkBviRvSz-sYOdjMEs-tvgk,4579
+notionary/elements/heading_element.py,sha256=kqgjyfaawEODir2tzDyf7-7wm38DbqoZnsH5k94GsA0,3013
+notionary/elements/image_element.py,sha256=cwdovaWK8e4uZJU97l_fJ2etAxAgM2rG2EE34t4eag8,4758
+notionary/elements/mention_element.py,sha256=L4t6eAY3RcbOqIiwVT_CAqwatDtP4tBs9FaqRhaCbpQ,8227
+notionary/elements/notion_block_element.py,sha256=BVrZH09vyojuacs3KGReVx3W0Ee6di_5o9E8N5sex28,1258
+notionary/elements/numbered_list_element.py,sha256=LHZ3aQjz8mHQKOd_oGgbaaj5Hv9_ZQVomj3GaTP8r1E,2663
+notionary/elements/paragraph_element.py,sha256=RfnC-whzmE2eysbTtTNsswmWBqxqK0lUdDlinHKsFMg,3255
+notionary/elements/qoute_element.py,sha256=NsMus2tiAKr8e2HBnHAZ442w40_qxL96z0-BzwR0uYU,6122
+notionary/elements/table_element.py,sha256=5ghOVjo5ocEGaQPPzbdbzcF8TQ3kLRJ2AYdsA2uHDJk,11249
+notionary/elements/text_inline_formatter.py,sha256=KvvTqctFNlzBo-OMoShAMnu-oK_AeiKYqslYQ-2dUFY,7963
+notionary/elements/todo_element.py,sha256=ND3oOzSnd0l1AUGTcG2NiHW50ZbI4-atjtNorLV5m2U,4124
+notionary/elements/toggle_element.py,sha256=h9vYkkAIUHzn-0mu31qC6UPdlk_0EFIsU5A4T_A2ZI8,11082
+notionary/elements/toggleable_heading_element.py,sha256=XdaPsd8anufwAACL8J-Egd_RcqPqZ1gFlzeol1GOyyc,9960
+notionary/elements/video_element.py,sha256=y0OmOYXdQBc2rSYAHRmA4l4rzNqPnyhuXbEipcgzQgY,5727
+notionary/elements/registry/block_registry.py,sha256=giWGcdgc3Z60wvfUr-FS6UMc-k-Q6DlXO8T0gl4fVC8,5027
+notionary/elements/registry/block_registry_builder.py,sha256=5dQhWiJ7jsyKUin1y7r-1Cmp0oOEAIfh6g91w8O4ydI,9319
+notionary/exceptions/database_exceptions.py,sha256=I-Tx6bYRLpi5pjGPtbT-Mqxvz3BFgYTiuZxknJeLxtI,2638
+notionary/exceptions/page_creation_exception.py,sha256=4v7IuZD6GsQLrqhDLriGjuG3ML638gAO53zDCrLePuU,281
+notionary/models/notion_block_response.py,sha256=gzL4C6K9QPcaMS6NbAZaRceSEnMbNwYBVVzxysza5VU,6002
+notionary/models/notion_database_response.py,sha256=Ij8XZniAi2BGjKn2fzT7auCAYAnTzL-jPTUjj5uH7i0,1240
+notionary/models/notion_page_response.py,sha256=r4fwMwwDocj92JdbSmyrzIqBKsnEaz4aDUiPabrg9BM,1762
+notionary/page/markdown_to_notion_converter.py,sha256=EuqUGNv2HZu67INOnGheeJkt7WHTWGuLnhEG72_Wv5Y,15833
+notionary/page/notion_page.py,sha256=Ap5h-6Ef9K8gtgrMM-msaYRM4q7OgFvzZS_xSjLdBiU,18049
+notionary/page/notion_page_factory.py,sha256=2A3M5Ub_kV2-q7PPRqDgfwBjhkGCwtL5i3Kr2RfvvVo,7213
+notionary/page/notion_to_markdown_converter.py,sha256=vUQss0J7LUFLULGvW27PjaTFuWi8OsRQAUBowSYorkM,6408
+notionary/page/content/notion_page_content_chunker.py,sha256=xRks74Dqec-De6-AVTxMPnXs-MSJBzSm1HfJfaHiKr8,3330
+notionary/page/content/page_content_retriever.py,sha256=btVWarx06KZ2A2ZRxNpNEvkeYwyyI2tnM8dKWSkiQGQ,2235
+notionary/page/content/page_content_writer.py,sha256=czBzNCGcwdpqNLSQPyna1s8Y7pjyPzDgJC3UUK5PLGA,3793
+notionary/page/metadata/metadata_editor.py,sha256=HI7m8Zn_Lz6x36rBnW1EnbicVS-4Q8NmCJYKN-OlY-c,5130
+notionary/page/metadata/notion_icon_manager.py,sha256=6a9GS5sT0trfuAb0hlF2Cw_Wc1oM59a1QA4kO9asvMA,2576
+notionary/page/metadata/notion_page_cover_manager.py,sha256=gHQSA8EtO4gbkMt_C3nKc0DF44SY_4ycd57cJSihdqk,2215
+notionary/page/properites/database_property_service.py,sha256=-UlA3NlquQAVyDy4Eyshy9J70UpIvv7K_PBPgvxVdCo,9909
+notionary/page/properites/page_property_manager.py,sha256=UVVcSwm3C9y-ggBdaca0o3Ib16YCm6do2ZDKLk8kdBA,5743
+notionary/page/properites/property_formatter.py,sha256=d_Nr5XQxgjB6VIS0u3ey14MOUKY416o_BvdXjbkUNAQ,3667
+notionary/page/properites/property_value_extractor.py,sha256=TZIbJXWcA1UQ7FutbGlJ96YoTdJp4I_Mz5qlTMgGFuU,2356
+notionary/page/relations/notion_page_relation_manager.py,sha256=tfkvLHClaYel_uEad1PIZ7yzhb2tXS-QrLn1CBvUuuw,11069
+notionary/page/relations/notion_page_title_resolver.py,sha256=dIjiEeHjjNT-DrIhz1nynkfHkMpUuJJFOEjb25Wy7f4,3575
+notionary/page/relations/page_database_relation.py,sha256=8lEp8fQjPwjWhA8nZu3k8mW6EEc54ki1Uwf4iUV1DOU,2245
+notionary/prompting/element_prompt_content.py,sha256=tHref-SKA81Ua_IQD2Km7y7BvFtHl74haSIjHNYE3FE,4403
+notionary/prompting/markdown_syntax_prompt_generator.py,sha256=xKzTF62SFKzadyC7FHcOxWueRzkKiJ054pBHu9B4aLg,3155
+notionary/util/logging_mixin.py,sha256=b6wHj0IoVSWXbHh0yynfJlwvIR33G2qmaGNzrqyb7Gs,1825
+notionary/util/page_id_utils.py,sha256=EYNMxgf-7ghzL5K8lKZBZfW7g5CsdY0Xuj4IYmU8RPk,1381
+notionary/util/warn_direct_constructor_usage.py,sha256=vyJR73F95XVSRWIbyij-82IGOpAne9SBPM25eDpZfSU,1715
+notionary-0.2.0.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
+notionary-0.2.0.dist-info/METADATA,sha256=LJEmoURn20Z9L2j8sK3GartZp5tQHhdQpt5tZ4dVSWA,8374
+notionary-0.2.0.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+notionary-0.2.0.dist-info/top_level.txt,sha256=fhONa6BMHQXqthx5PanWGbPL0b8rdFqhrJKVLf_adSs,10
+notionary-0.2.0.dist-info/RECORD,,

{notionary-0.1.29.dist-info → notionary-0.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.0)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

notionary/database/database_info_service.py

@@ -1,43 +0,0 @@
-from typing import Optional
-from notionary.notion_client import NotionClient
-
-
-class DatabaseInfoService:
-    """Service für den Zugriff auf Datenbankinformationen"""
-
-    def __init__(self, client: NotionClient, database_id: str):
-        self._client = client
-        self.database_id = database_id
-        self._title = None
-
-    async def fetch_database_title(self) -> str:
-        """
-        Fetch the database title from the Notion API.
-
-        Returns:
-            The database title or "Untitled" if no title is found
-        """
-        db_details = await self._client.get(f"databases/{self.database_id}")
-        if not db_details:
-            return "Untitled"
-
-        title = "Untitled"
-        if "title" in db_details:
-            title_parts = []
-            for text_obj in db_details["title"]:
-                if "plain_text" in text_obj:
-                    title_parts.append(text_obj["plain_text"])
-
-            if title_parts:
-                title = "".join(title_parts)
-
-        return title
-
-    @property
-    def title(self) -> Optional[str]:
-        return self._title
-
-    async def load_title(self) -> str:
-        """Lädt den Titel der Datenbank und speichert ihn im Cache"""
-        self._title = await self.fetch_database_title()
-        return self._title

notionary/elements/prompts/synthax_prompt_builder.py

@@ -1,150 +0,0 @@
-from typing import Type, List
-from notionary.elements.notion_block_element import NotionBlockElement
-
-
-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.
-    """
-
-    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.
-
-# Understanding Notion Blocks
-Notion documents are composed of individual blocks. Each block has a specific type (paragraph, heading, list item, etc.) and format. 
-The Markdown syntax you use directly maps to these Notion blocks.
-
-## Inline Formatting
-Inline formatting can be used within most block types to style your text. You can combine multiple formatting options.
-**Syntax:** **bold**, *italic*, `code`, ~~strikethrough~~, __underline__, [text](url)
-**Examples:** 
-- This text has a **bold** word.
-- This text has an *italic* word.
-- This text has `code` formatting.
-- This text has ~~strikethrough~~ formatting.
-- This text has __underlined__ formatting.
-- This has a [hyperlink](https://example.com).
-- You can **combine *different* formatting** styles.
-
-**When to use:** Use inline formatting to highlight important words, provide emphasis, show code or paths, or add hyperlinks. This helps create visual hierarchy and improves scanability.
-
-## Spacers and Block Separation
-There are two ways to create visual separation between blocks:
-
-1. **Empty Lines**: Simply add a blank line between blocks
-   **Syntax:** Press Enter twice between blocks
-   **Example:** 
-   First paragraph.
-
-   Second paragraph after an empty line.
-
-2. **HTML Comment Spacer**: For more deliberate spacing between logical sections
-   **Syntax:** <!-- spacer -->
-   **Example:**
-   ## First Section
-   Content here.
-   <!-- spacer -->
-   ## Second Section
-   More content here.
-
-**When to use:** Use empty lines for basic separation between blocks. Use the HTML comment spacer (<!-- spacer -->) to create more obvious visual separation between major logical sections of your document.
-
-{element_docs}
-
-CRITICAL USAGE GUIDELINES:
-
-1. Do NOT start content with a level 1 heading (# Heading). In Notion, the page title is already displayed in the metadata, so starting with an H1 heading is redundant. Begin with H2 (## Heading) or lower for section headings.
-
-2. INLINE FORMATTING - VERY IMPORTANT:
-   ✅ You can use inline formatting within almost any block type.
-   ✅ Combine **bold**, *italic*, `code`, and other formatting as needed.
-   ✅ Format text to create visual hierarchy and emphasize important points.
-   ❌ DO NOT overuse formatting - be strategic with formatting for best readability.
-
-3. BACKTICK HANDLING - EXTREMELY IMPORTANT:
-   ❌ NEVER wrap entire content or responses in triple backticks (```).
-   ❌ DO NOT use triple backticks (```) for anything except CODE BLOCKS or DIAGRAMS.
-   ❌ DO NOT use triple backticks to mark or highlight regular text or examples.
-   ✅ USE triple backticks ONLY for actual programming code, pseudocode, or specialized notation.
-   ✅ For inline code, use single backticks (`code`).
-   ✅ When showing Markdown syntax examples, use inline code formatting with single backticks.
-
-4. BLOCK SEPARATION - IMPORTANT:
-   ✅ Use empty lines between different blocks to ensure proper rendering in Notion.
-   ✅ For major logical sections, add the HTML comment spacer: <!-- spacer -->
-   ✅ This spacer creates better visual breaks between key sections of your document.
-   ⚠️ While headings can sometimes work without an empty line before the following paragraph, including empty lines between all block types ensures consistent rendering.
-
-5. TOGGLE BLOCKS - NOTE:
-   ✅ For toggle blocks and collapsible headings, use pipe prefixes (|) for content.
-   ✅ Each line within a toggle should start with a pipe character followed by a space.
-   ❌ Do not use the pipe character for any other blocks.
-
-6. CONTENT FORMATTING - CRITICAL:
-   ❌ DO NOT include introductory phrases like "I understand that..." or "Here's the content...".
-   ✅ Provide ONLY the requested content directly without any prefacing text or meta-commentary.
-   ✅ Generate just the content itself, formatted according to these guidelines.
-    """
-
-    @staticmethod
-    def generate_element_doc(element_class: Type[NotionBlockElement]) -> str:
-        """
-        Generates documentation for a specific NotionBlockElement in a compact format.
-        Uses the element's get_llm_prompt_content method if available.
-        """
-        class_name = element_class.__name__
-        element_name = class_name.replace("Element", "")
-
-        # Check if the class has the get_llm_prompt_content method
-        if not hasattr(element_class, "get_llm_prompt_content") or not callable(
-            getattr(element_class, "get_llm_prompt_content")
-        ):
-            return f"## {element_name}"
-
-        # Get the element content
-        content = element_class.get_llm_prompt_content()
-
-        doc_parts = [
-            f"## {element_name}",
-            f"{content.description}",
-            f"**Syntax:** {content.syntax}",
-            f"**Example:** {content.examples[0]}" if content.examples else "",
-            f"**When to use:** {content.when_to_use}",
-        ]
-
-        if content.avoid:
-            doc_parts.append(f"**Avoid:** {content.avoid}")
-
-        return "\n".join([part for part in doc_parts if part])
-
-    @classmethod
-    def generate_element_docs(
-        cls, element_classes: List[Type[NotionBlockElement]]
-    ) -> str:
-        """
-        Generates complete documentation for all provided element classes.
-        """
-        docs = [
-            "# Markdown Syntax for Notion Blocks",
-            "The following Markdown patterns are supported for creating Notion blocks:",
-        ]
-
-        # Generate docs for each element
-        for element in element_classes:
-            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.
-        """
-        element_docs = cls.generate_element_docs(element_classes)
-        return cls.SYSTEM_PROMPT_TEMPLATE.format(element_docs=element_docs)