notionary 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

notionary/database/database_discovery.py

@@ -26,29 +26,7 @@ class DatabaseDiscovery(LoggingMixin):
         self._client = client if client else NotionClient()
         self.logger.info("DatabaseDiscovery initialized")
 
-    async def discover(self, page_size: int = 100) -> List[Tuple[str, str]]:
-        """
-        Discover all accessible databases and return their titles and IDs.
-
-        Args:
-            page_size: The number of databases to fetch per request
-
-        Returns:
-            List of tuples containing (database_title, database_id)
-        """
-        databases = []
-
-        async for database in self._iter_databases(page_size):
-            db_id = database.get("id")
-            if not db_id:
-                continue
-
-            title = self._extract_database_title(database)
-            databases.append((title, db_id))
-
-        return databases
-
-    async def discover_and_print(self, page_size: int = 100) -> List[Tuple[str, str]]:
+    async def __call__(self, page_size: int = 100) -> List[Tuple[str, str]]:
         """
         Discover databases and print the results in a nicely formatted way.
 
@@ -61,7 +39,7 @@ class DatabaseDiscovery(LoggingMixin):
         Returns:
             The same list of databases as discover() for further processing
         """
-        databases = await self.discover(page_size)
+        databases = await self._discover(page_size)
 
         if not databases:
             print("\n⚠️ No databases found!")
@@ -78,6 +56,28 @@ class DatabaseDiscovery(LoggingMixin):
 
         return databases
 
+    async def _discover(self, page_size: int = 100) -> List[Tuple[str, str]]:
+        """
+        Discover all accessible databases and return their titles and IDs.
+
+        Args:
+            page_size: The number of databases to fetch per request
+
+        Returns:
+            List of tuples containing (database_title, database_id)
+        """
+        databases = []
+
+        async for database in self._iter_databases(page_size):
+            db_id = database.get("id")
+            if not db_id:
+                continue
+
+            title = self._extract_database_title(database)
+            databases.append((title, db_id))
+
+        return databases
+
     async def _iter_databases(
         self, page_size: int = 100
     ) -> AsyncGenerator[Dict[str, Any], None]:

notionary/elements/code_block_element.py

@@ -15,13 +15,17 @@ class CodeBlockElement(NotionBlockElement):
     ```language
     code content
     ```
+    Caption: optional caption text
 
     Where:
     - language is optional and specifies the programming language
     - code content is the code to be displayed
+    - Caption line is optional and must appear immediately after the closing ```
     """
 
-    PATTERN = re.compile(r"```(\w*)\n([\s\S]+?)```", re.MULTILINE)
+    PATTERN = re.compile(
+        r"```(\w*)\n([\s\S]+?)```(?:\n(?:Caption|caption):\s*(.+))?", re.MULTILINE
+    )
 
     @classmethod
     def match_markdown(cls, text: str) -> bool:
@@ -42,25 +46,18 @@ class CodeBlockElement(NotionBlockElement):
 
         language = match.group(1) or "plain text"
         content = match.group(2)
+        caption = match.group(3)
 
         if content.endswith("\n"):
             content = content[:-1]
 
-        return {
+        block = {
             "type": "code",
             "code": {
                 "rich_text": [
                     {
                         "type": "text",
                         "text": {"content": content},
-                        "annotations": {
-                            "bold": False,
-                            "italic": False,
-                            "strikethrough": False,
-                            "underline": False,
-                            "code": False,
-                            "color": "default",
-                        },
                         "plain_text": content,
                     }
                 ],
@@ -68,6 +65,18 @@ class CodeBlockElement(NotionBlockElement):
             },
         }
 
+        # Add caption if provided
+        if caption and caption.strip():
+            block["code"]["caption"] = [
+                {
+                    "type": "text",
+                    "text": {"content": caption.strip()},
+                    "plain_text": caption.strip(),
+                }
+            ]
+
+        return block
+
     @classmethod
     def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
         """Convert Notion code block to markdown code block."""
@@ -84,8 +93,20 @@ class CodeBlockElement(NotionBlockElement):
 
         language = code_data.get("language", "")
 
+        # Extract caption if present
+        caption_text = ""
+        caption_data = code_data.get("caption", [])
+        for caption_block in caption_data:
+            caption_text += caption_block.get("plain_text", "")
+
         # Format as a markdown code block
-        return f"```{language}\n{content}\n```"
+        result = f"```{language}\n{content}\n```"
+
+        # Add caption if present
+        if caption_text.strip():
+            result += f"\nCaption: {caption_text}"
+
+        return result
 
     @classmethod
     def find_matches(cls, text: str) -> List[Tuple[int, int, Dict[str, Any]]]:
@@ -102,6 +123,7 @@ class CodeBlockElement(NotionBlockElement):
         for match in CodeBlockElement.PATTERN.finditer(text):
             language = match.group(1) or "plain text"
             content = match.group(2)
+            caption = match.group(3)
 
             # Remove trailing newline if present
             if content.endswith("\n"):
@@ -121,6 +143,16 @@ class CodeBlockElement(NotionBlockElement):
                 },
             }
 
+            # Add caption if provided
+            if caption and caption.strip():
+                block["code"]["caption"] = [
+                    {
+                        "type": "text",
+                        "text": {"content": caption.strip()},
+                        "plain_text": caption.strip(),
+                    }
+                ]
+
             matches.append((match.start(), match.end(), block))
 
         return matches
@@ -139,25 +171,34 @@ class CodeBlockElement(NotionBlockElement):
             .with_description(
                 "Use fenced code blocks to format content as code. Supports language annotations like "
                 "'python', 'json', or 'mermaid'. Useful for displaying code, configurations, command-line "
-                "examples, or diagram syntax. Also suitable for explaining or visualizing systems with diagram languages."
+                "examples, or diagram syntax. Also suitable for explaining or visualizing systems with diagram languages. "
+                "Code blocks can include optional captions for better documentation."
             )
             .with_usage_guidelines(
                 "Use code blocks when you want to present technical content like code snippets, terminal commands, "
-                "JSON structures, or system diagrams. Especially helpful when structure and formatting are essential."
+                "JSON structures, or system diagrams. Especially helpful when structure and formatting are essential. "
+                "Add captions to provide context, explanations, or titles for your code blocks."
+            )
+            .with_syntax(
+                "```language\ncode content\n```\nCaption: optional caption text\n\n"
+                "OR\n\n"
+                "```language\ncode content\n```"
             )
-            .with_syntax("```language\ncode content\n```")
             .with_examples(
                 [
-                    "```python\nprint('Hello, world!')\n```",
-                    '```json\n{"name": "Alice", "age": 30}\n```',
-                    "```mermaid\nflowchart TD\n  A --> B\n```",
+                    "```python\nprint('Hello, world!')\n```\nCaption: Basic Python greeting example",
+                    '```json\n{"name": "Alice", "age": 30}\n```\nCaption: User data structure',
+                    "```mermaid\nflowchart TD\n  A --> B\n```\nCaption: Simple flow diagram",
+                    '```bash\ngit commit -m "Initial commit"\n```',  # Without caption
                 ]
             )
             .with_avoidance_guidelines(
                 "NEVER EVER wrap markdown content with ```markdown. Markdown should be written directly without code block formatting. "
                 "NEVER use ```markdown under any circumstances. "
                 "For Mermaid diagrams, use ONLY the default styling without colors, backgrounds, or custom styling attributes. "
-                "Keep Mermaid diagrams simple and minimal without any styling or color modifications."
+                "Keep Mermaid diagrams simple and minimal without any styling or color modifications. "
+                "Captions must appear immediately after the closing ``` on a new line starting with 'Caption:' - "
+                "no empty lines between the code block and the caption."
             )
             .build()
         )

notionary/elements/column_element.py

@@ -0,0 +1,204 @@
+import re
+from typing import Dict, Any, Optional, List, Tuple
+from notionary.elements.notion_block_element import NotionBlockElement
+from notionary.prompting.element_prompt_content import (
+    ElementPromptBuilder,
+    ElementPromptContent,
+)
+
+
+# Fix Column Element
+class ColumnsElement(NotionBlockElement):
+    """
+    Handles conversion between Markdown column syntax and Notion column_list blocks.
+
+    Note: Due to Notion's column structure, this element requires special handling.
+    It returns a column_list block with placeholder content, as the actual columns
+    must be added as children after the column_list is created.
+    """
+
+    PATTERN = re.compile(
+        r"^::: columns\n((?:::: column\n(?:.*?\n)*?:::\n?)+):::\s*$",
+        re.MULTILINE | re.DOTALL,
+    )
+
+    COLUMN_PATTERN = re.compile(r"::: column\n(.*?):::", re.DOTALL)
+
+    @classmethod
+    def match_markdown(cls, text: str) -> bool:
+        """Check if text contains a columns block."""
+        return bool(cls.PATTERN.search(text))
+
+    @classmethod
+    def match_notion(cls, block: Dict[str, Any]) -> bool:
+        """Check if block is a Notion column_list block."""
+        return block.get("type") == "column_list"
+
+    @classmethod
+    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
+        """Convert markdown columns to Notion column_list block."""
+        match = cls.PATTERN.search(text)
+        if not match:
+            return None
+
+        columns_content = match.group(1)
+        column_matches = cls.COLUMN_PATTERN.findall(columns_content)
+
+        if not column_matches:
+            return None
+
+        return {"type": "column_list", "column_list": {}}
+
+    @classmethod
+    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
+        """Convert Notion column_list block to markdown columns."""
+        if block.get("type") != "column_list":
+            return None
+
+        # In a real implementation, you'd need to fetch the child column blocks
+        # This is a placeholder showing the expected output format
+        markdown = "::: columns\n"
+
+        # Placeholder for column content extraction
+        # In reality, you'd iterate through the child blocks
+        markdown += "::: column\nColumn content here\n:::\n"
+
+        markdown += ":::"
+        return markdown
+
+    @classmethod
+    def find_matches(cls, text: str) -> List[Tuple[int, int, Dict[str, Any]]]:
+        """
+        Find all column block matches in the text and return their positions.
+
+        Args:
+            text: The text to search in
+
+        Returns:
+            List of tuples with (start_pos, end_pos, block_data)
+        """
+        matches = []
+        for match in cls.PATTERN.finditer(text):
+            block_data = cls.markdown_to_notion(match.group(0))
+            if block_data:
+                matches.append((match.start(), match.end(), block_data))
+
+        return matches
+
+    @classmethod
+    def is_multiline(cls) -> bool:
+        return True
+
+    @classmethod
+    def get_llm_prompt_content(cls) -> ElementPromptContent:
+        """
+        Returns structured LLM prompt metadata for the columns element.
+        """
+        return (
+            ElementPromptBuilder()
+            .with_description(
+                "Create multi-column layouts using Pandoc-style fenced divs. Perfect for side-by-side comparisons, "
+                "parallel content, or creating newsletter-style layouts. Each column can contain any markdown content "
+                "including headers, lists, images, and even nested blocks."
+            )
+            .with_usage_guidelines(
+                "Use columns when you need to present information side-by-side for comparison, create visual balance "
+                "in your layout, or organize related content in parallel. Great for pros/cons lists, before/after "
+                "comparisons, or displaying multiple related items. Keep column content balanced in length for best "
+                "visual results."
+            )
+            .with_syntax(
+                "::: columns\n"
+                "::: column\n"
+                "Content for first column\n"
+                ":::\n"
+                "::: column\n"
+                "Content for second column\n"
+                ":::\n"
+                ":::"
+            )
+            .with_examples(
+                [
+                    # Simple two-column example
+                    "::: columns\n"
+                    "::: column\n"
+                    "### Pros\n"
+                    "- Fast performance\n"
+                    "- Easy to use\n"
+                    "- Great documentation\n"
+                    ":::\n"
+                    "::: column\n"
+                    "### Cons\n"
+                    "- Limited customization\n"
+                    "- Requires subscription\n"
+                    "- No offline mode\n"
+                    ":::\n"
+                    ":::",
+                    # Three-column example
+                    "::: columns\n"
+                    "::: column\n"
+                    "**Python**\n"
+                    "```python\n"
+                    "print('Hello')\n"
+                    "```\n"
+                    ":::\n"
+                    "::: column\n"
+                    "**JavaScript**\n"
+                    "```javascript\n"
+                    "console.log('Hello');\n"
+                    "```\n"
+                    ":::\n"
+                    "::: column\n"
+                    "**Ruby**\n"
+                    "```ruby\n"
+                    "puts 'Hello'\n"
+                    "```\n"
+                    ":::\n"
+                    ":::",
+                    # Mixed content example
+                    "::: columns\n"
+                    "::: column\n"
+                    "![Image](url)\n"
+                    "Product photo\n"
+                    ":::\n"
+                    "::: column\n"
+                    "## Product Details\n"
+                    "- Price: $99\n"
+                    "- Weight: 2kg\n"
+                    "- Color: Blue\n"
+                    "\n"
+                    "[Order Now](link)\n"
+                    ":::\n"
+                    ":::",
+                ]
+            )
+            .with_avoidance_guidelines(
+                "Avoid nesting column blocks within column blocks - this creates confusing layouts. "
+                "Don't use columns for content that should be read sequentially. Keep the number of columns "
+                "reasonable (2-4 max) for readability. Ensure each ::: marker is on its own line with proper "
+                "nesting. Don't mix column syntax with regular markdown formatting on the same line."
+            )
+            .build()
+        )
+
+    @classmethod
+    def get_column_content(cls, text: str) -> List[str]:
+        """
+        Extract the content of individual columns from the markdown.
+        This is a helper method that can be used by the implementation
+        to process column content separately.
+
+        Args:
+            text: The complete columns markdown block
+
+        Returns:
+            List of column content strings
+        """
+        match = cls.PATTERN.search(text)
+        if not match:
+            return []
+
+        columns_content = match.group(1)
+        return [
+            content.strip() for content in cls.COLUMN_PATTERN.findall(columns_content)
+        ]

notionary/elements/divider_element.py

@@ -57,11 +57,11 @@ class DividerElement(NotionBlockElement):
                 "Creates a horizontal divider line to visually separate sections of content."
             )
             .with_usage_guidelines(
-                "Use to create clear visual breaks between different sections without requiring headings."
+                "Use dividers only sparingly and only when the user explicitly asks for them. Dividers create strong visual breaks between content sections, so they should not be used unless specifically requested by the user."
             )
             .with_syntax("---")
             .with_examples(
                 ["## Section 1\nContent\n\n---\n\n## Section 2\nMore content"]
             )
             .build()
-        )
+        )

notionary/elements/registry/block_registry.py

@@ -126,7 +126,7 @@ class BlockRegistry:
 
         formatter_names = [e.__name__ for e in element_classes]
         if "TextInlineFormatter" not in formatter_names:
-            element_classes = [TextInlineFormatter] + element_classes
+            element_classes = element_classes +  [TextInlineFormatter]
 
         return MarkdownSyntaxPromptGenerator.generate_system_prompt(element_classes)
 

notionary/elements/registry/block_registry_builder.py

@@ -27,6 +27,7 @@ from notionary.elements.toggleable_heading_element import ToggleableHeadingEleme
 from notionary.elements.video_element import VideoElement
 from notionary.elements.toggle_element import ToggleElement
 from notionary.elements.bookmark_element import BookmarkElement
+from notionary.elements.column_element import ColumnsElement
 
 
 class BlockRegistryBuilder:
@@ -262,6 +263,12 @@ class BlockRegistryBuilder:
     def with_toggleable_heading_element(self) -> BlockRegistryBuilder:
         return self.add_element(ToggleableHeadingElement)
 
+    def with_columns(self) -> BlockRegistryBuilder:
+        """
+        Add support for column elements.
+        """
+        return self.add_element(ColumnsElement)
+
     def build(self) -> BlockRegistry:
         """
         Build and return the configured BlockRegistry instance.

notionary/page/content/page_content_retriever.py

@@ -1,4 +1,3 @@
-import json
 from typing import Any, Dict, List, Optional
 
 from notionary.elements.registry.block_registry import BlockRegistry
@@ -25,7 +24,6 @@ class PageContentRetriever(LoggingMixin):
 
     async def get_page_content(self) -> str:
         blocks = await self._get_page_blocks_with_children()
-        print("blocks", json.dumps(blocks, indent=2))
         return self._notion_to_markdown_converter.convert(blocks)
 
     async def _get_page_blocks_with_children(

notionary/page/content/page_content_writer.py

@@ -1,4 +1,5 @@
 from typing import Any, Dict
+from textwrap import dedent
 
 from notionary.elements.divider_element import DividerElement
 from notionary.elements.registry.block_registry import BlockRegistry
@@ -37,15 +38,24 @@ class PageContentWriter(LoggingMixin):
     async def append_markdown(self, markdown_text: str, append_divider=False) -> bool:
         """
         Append markdown text to a Notion page, automatically handling content length limits.
-
         """
+        # Check for leading whitespace in the first three lines and log a warning if found
+        first_three_lines = markdown_text.split('\n')[:3]
+        if any(line.startswith(' ') or line.startswith('\t') for line in first_three_lines):
+            self.logger.warning(
+                "Leading whitespace detected in input markdown. Consider using textwrap.dedent or similar logic: "
+                "this code is indented the wrong way, which could lead to formatting issues."
+            )
+        
+        markdown_text = "\n".join(line.lstrip() for line in markdown_text.split("\n"))
+
         if append_divider and not self.block_registry.contains(DividerElement):
             self.logger.warning(
                 "DividerElement not registered. Appending divider skipped."
             )
             append_divider = False
 
-        # Append divider in markdonw format as it will be converted to a Notion divider block
+        # Append divider in markdown format as it will be converted to a Notion divider block
         if append_divider:
             markdown_text = markdown_text + "\n\n---\n\n"
 

notionary/page/markdown_to_notion_converter.py

@@ -1,4 +1,5 @@
 from typing import Dict, Any, List, Optional, Tuple
+import re
 
 from notionary.elements.registry.block_registry import BlockRegistry
 from notionary.elements.registry.block_registry_builder import (
@@ -9,9 +10,11 @@ from notionary.elements.registry.block_registry_builder import (
 class MarkdownToNotionConverter:
     """Converts Markdown text to Notion API block format with support for pipe syntax for nested structures."""
 
-    SPACER_MARKER = "<!-- spacer -->"
+    SPACER_MARKER = "---spacer---"
     TOGGLE_ELEMENT_TYPES = ["ToggleElement", "ToggleableHeadingElement"]
     PIPE_CONTENT_PATTERN = r"^\|\s?(.*)$"
+    HEADING_PATTERN = r"^(#{1,6})\s+(.+)$"
+    DIVIDER_PATTERN = r"^-{3,}$"
 
     def __init__(self, block_registry: Optional[BlockRegistry] = None):
         """Initialize the converter with an optional custom block registry."""
@@ -24,9 +27,12 @@ class MarkdownToNotionConverter:
         if not markdown_text:
             return []
 
+        # Preprocess markdown to add spacers before headings and dividers
+        processed_markdown = self._add_spacers_before_elements(markdown_text)
+
         # Collect all blocks with their positions in the text
         all_blocks_with_positions = self._collect_all_blocks_with_positions(
-            markdown_text
+            processed_markdown
         )
 
         # Sort all blocks by their position in the text
@@ -38,6 +44,39 @@ class MarkdownToNotionConverter:
         # Process spacing between blocks
         return self._process_block_spacing(blocks)
 
+    def _add_spacers_before_elements(self, markdown_text: str) -> str:
+        """Add spacer markers before every heading (except the first one) and before every divider."""
+        lines = markdown_text.split('\n')
+        processed_lines = []
+        found_first_heading = False
+        
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            
+            # Check if line is a heading
+            if re.match(self.HEADING_PATTERN, line):
+                if found_first_heading:
+                    # Only add a single spacer line before headings (no extra line breaks)
+                    processed_lines.append(self.SPACER_MARKER)
+                else:
+                    found_first_heading = True
+                
+                processed_lines.append(line)
+            
+            # Check if line is a divider
+            elif re.match(self.DIVIDER_PATTERN, line):
+                # Only add a single spacer line before dividers (no extra line breaks)
+                processed_lines.append(self.SPACER_MARKER)
+                processed_lines.append(line)
+            
+            else:
+                processed_lines.append(line)
+            
+            i += 1
+        
+        return '\n'.join(processed_lines)
+
     def _collect_all_blocks_with_positions(
         self, markdown_text: str
     ) -> List[Tuple[int, int, Dict[str, Any]]]:
@@ -75,13 +114,10 @@ class MarkdownToNotionConverter:
         if not toggleable_elements:
             return []
 
-        # Process each toggleable element type
         for element in toggleable_elements:
-            if hasattr(element, "find_matches"):
-                # Find matches with context awareness
-                matches = element.find_matches(text, self.convert, context_aware=True)
-                if matches:
-                    toggleable_blocks.extend(matches)
+            matches = element.find_matches(text, self.convert, context_aware=True)
+            if matches:
+                toggleable_blocks.extend(matches)
 
         return toggleable_blocks
 
@@ -112,9 +148,6 @@ class MarkdownToNotionConverter:
 
         multiline_blocks = []
         for element in multiline_elements:
-            if not hasattr(element, "find_matches"):
-                continue
-
             matches = element.find_matches(text)
 
             if not matches:
@@ -202,8 +235,6 @@ class MarkdownToNotionConverter:
 
     def _is_pipe_syntax_line(self, line: str) -> bool:
         """Check if a line uses pipe syntax (for nested content)."""
-        import re
-
         return bool(re.match(self.PIPE_CONTENT_PATTERN, line))
 
     def _process_line(
@@ -433,4 +464,4 @@ class MarkdownToNotionConverter:
             return False
 
         rich_text = block.get("paragraph", {}).get("rich_text", [])
-        return not rich_text or len(rich_text) == 0
+        return not rich_text or len(rich_text) == 0

notionary/prompting/markdown_syntax_prompt_generator.py

@@ -1,6 +1,6 @@
-from textwrap import dedent
 from typing import Type, List
 from notionary.elements.notion_block_element import NotionBlockElement
+from notionary.elements.text_inline_formatter import TextInlineFormatter
 
 
 class MarkdownSyntaxPromptGenerator:
@@ -11,10 +11,9 @@ class MarkdownSyntaxPromptGenerator:
     and formats them optimally for LLMs.
     """
 
-    SYSTEM_PROMPT_TEMPLATE = dedent(
-        """
-    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.
+    SYSTEM_PROMPT_TEMPLATE = (
+    """
+    You create content for Notion pages using Markdown syntax with special Notion extensions.
 
     # Understanding Notion Blocks
 
@@ -27,29 +26,36 @@ class MarkdownSyntaxPromptGenerator:
 
     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, use the spacer element (see documentation below).
-    ⚠️ While headings can sometimes work without an empty line before the following paragraph, including empty lines between all block types ensures consistent rendering.
-
-    5. 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."""
+    2. 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.
+
+    3. 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.
+    - USE INLINE FORMATTING to enhance readability:
+        - Use *italic* for emphasis, terminology, and definitions
+        - Use `code` for technical terms, file paths, variables, and commands
+        - Use **bold** sparingly for truly important information
+        - Use appropriate inline formatting naturally throughout the content, but don't overuse it
+
+    4. USER INSTRUCTIONS - VERY IMPORTANT:
+    - Follow the user's formatting instructions EXACTLY and in the specified order
+    - When the user requests specific elements (e.g., "first a callout, then 4 bullet points"), create them in that precise sequence
+    - Adhere strictly to any structural requirements provided by the user
+    - Do not deviate from or reinterpret the user's formatting requests
+
+   5. ADD EMOJIS TO HEADINGS - REQUIRED UNLESS EXPLICITLY TOLD NOT TO:
+   - ALWAYS add appropriate emojis at the beginning of headings to improve structure and readability
+   - Choose emojis that represent the content or theme of each section
+   - Format as: ## 🚀 Heading Text (with space after emoji)
+   - Only omit emojis if the user explicitly instructs you not to use them
+    """
     )
 
     @staticmethod
@@ -108,4 +114,4 @@ class MarkdownSyntaxPromptGenerator:
         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)
+        return cls.SYSTEM_PROMPT_TEMPLATE.format(element_docs=element_docs)

notionary-0.2.7.dist-info/METADATA

@@ -0,0 +1,245 @@
+Metadata-Version: 2.4
+Name: notionary
+Version: 0.2.7
+Summary: A toolkit to convert between Markdown and Notion blocks
+Home-page: https://github.com/mathisarends/notionary
+Author: Mathis Arends
+Author-email: mathisarends27@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.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
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Notionary 📝
+
+[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+**Notionary** is a powerful Python library for interacting with the Notion API, making it easy to create, update, and manage Notion pages and databases programmatically with a clean, intuitive interface. It's specifically designed to be the foundation for AI-driven Notion content generation.
+
+---
+
+## Features
+
+- **Rich Markdown Support**: Create Notion pages using intuitive Markdown syntax with custom extensions
+- **Dynamic Database Operations**: Create, update, and query database entries with schema auto-detection
+- **Extensible Block Registry**: Add, customize, or remove Notion block elements with a flexible registry pattern
+- **LLM-Ready Prompts**: Generate system prompts explaining Markdown syntax for LLMs to create Notion content
+- **Async-First Design**: Built for modern Python with full async/await support
+- **Schema-Based Validation**: Automatic property validation based on database schemas
+- **Intelligent Content Conversion**: Bidirectional conversion between Markdown and Notion blocks
+
+---
+
+## Installation
+
+```bash
+pip install notionary
+```
+
+---
+
+## Quick Start
+
+### Creating and Managing Pages
+
+```python
+import asyncio
+from notionary import NotionPage
+
+async def main():
+    # Create a page from URL
+    page = NotionPage.from_url("https://www.notion.so/your-page-url")
+
+    # Or find by name
+    page = await NotionPage.from_page_name("My Project Page")
+
+    # Update page metadata
+    await page.set_title("Updated Title")
+    await page.set_emoji_icon("🚀")
+    await page.set_random_gradient_cover()
+
+    # Add markdown content
+    markdown = """
+    # Project Overview
+
+    !> [💡] This page was created programmatically using Notionary.
+
+    ## Features
+    - **Rich** Markdown support
+    - Async functionality
+    - Custom syntax extensions
+
+    +++ Implementation Details
+    | Notionary uses a custom converter to transform Markdown into Notion blocks.
+    | This makes it easy to create rich content programmatically.
+    """
+
+    await page.replace_content(markdown)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Working with Databases
+
+```python
+import asyncio
+from notionary import NotionDatabase, DatabaseDiscovery
+
+async def main():
+    # Discover available databases
+    discovery = DatabaseDiscovery()
+    await discovery()
+
+    # Connect to a database by name
+    db = await NotionDatabase.from_database_name("Projects")
+
+    # Create a new page in the database
+    page = await db.create_blank_page()
+
+    # Set properties
+    await page.set_property_value_by_name("Status", "In Progress")
+    await page.set_property_value_by_name("Priority", "High")
+
+    # Query pages from database
+    async for page in db.iter_pages():
+        title = await page.get_title()
+        print(f"Page: {title}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Custom Markdown Syntax
+
+Notionary extends standard Markdown with special syntax to support Notion-specific features:
+
+### Text Formatting
+
+- Standard: `**bold**`, `*italic*`, `~~strikethrough~~`, `` `code` ``
+- Links: `[text](url)`
+- Quotes: `> This is a quote`
+- Divider: `---`
+
+### Callouts
+
+```markdown
+!> [💡] This is a default callout with the light bulb emoji  
+!> [🔔] This is a notification with a bell emoji  
+!> [⚠️] Warning: This is an important note
+```
+
+### Toggles
+
+```markdown
++++ How to use Notionary
+| 1. Initialize with NotionPage  
+| 2. Update metadata with set_title(), set_emoji_icon(), etc.  
+| 3. Add content with replace_content() or append_markdown()
+```
+
+### Code Blocks
+
+```python
+def hello_world():
+    print("Hello from Notionary!")
+```
+
+### To-do Lists
+
+```markdown
+- [ ] Define project scope
+- [x] Create timeline
+- [ ] Assign resources
+```
+
+### Tables
+
+```markdown
+| Feature         | Status      | Priority |
+| --------------- | ----------- | -------- |
+| API Integration | Complete    | High     |
+| Documentation   | In Progress | Medium   |
+```
+
+### More Elements
+
+```markdown
+![Caption](https://example.com/image.jpg)  
+@[Caption](https://youtube.com/watch?v=...)  
+[bookmark](https://example.com "Title" "Description")
+```
+
+## Block Registry & Customization
+
+```python
+from notionary import NotionPage, BlockRegistryBuilder
+
+# Create a custom registry with only the elements you need
+custom_registry = (
+    BlockRegistryBuilder()
+    .with_headings()
+    .with_callouts()
+    .with_toggles()
+    .with_code()
+    .with_todos()
+    .with_paragraphs()
+    .build()
+)
+
+# Apply this registry to a page
+page = NotionPage.from_url("https://www.notion.so/your-page-url")
+page.block_registry = custom_registry
+ark
+# Replace content using only supported elements
+await page.replace_content("# Custom heading with selected elements only")
+```
+
+## AI-Ready: Generate LLM Prompts
+
+```python
+from notionary import BlockRegistryBuilder
+
+# Create a registry with all standard elements
+registry = BlockRegistryBuilder.create_full_registry()
+
+# Generate the LLM system prompt
+llm_system_prompt = registry.get_notion_markdown_syntax_prompt()
+print(llm_system_prompt)
+```
+
+## Examples
+
+See the `examples/` folder for:
+
+- [Database discovery and querying](examples/database_discovery_example.py)
+- [Rich page creation with Markdown](examples/page_example.py)
+- [Database management](examples/database_management_example.py)
+- [Iterating through database entries](examples/database_iteration_example.py)
+- [Temporary usage & debugging](examples/temp.py)
+
+## Perfect for AI Agents and Automation
+
+- **LLM Integration**: Generate Notion-compatible content with any LLM using the system prompt generator
+- **Dynamic Content Generation**: AI agents can generate content in Markdown and render it directly as Notion pages
+- **Schema-Aware Operations**: Automatically validate and format properties based on database schemas
+- **Simplified API**: Clean, intuitive interface for both human developers and AI systems
+
+## Contributing
+
+Contributions welcome — feel free to submit a pull request!

{notionary-0.2.5.dist-info → notionary-0.2.7.dist-info}/RECORD

@@ -1,6 +1,6 @@
 notionary/__init__.py,sha256=hPvZ-iqt5R_dAs9KaRBhC5eXzuQ5uvt-9EaU2O_7bZw,691
 notionary/notion_client.py,sha256=O-lvy2-jMNSDc_8cWKuGVfckCdc1_PiQOlfxQKjQ6_A,7325
-notionary/database/database_discovery.py,sha256=qDGFhXG9s-_6CXdRg8tMiwX4dvX7jLjgAUFPSNlYtlI,4506
+notionary/database/database_discovery.py,sha256=Ebn-9HuNb8fwqf9KP4Vyys8t5zCKUOqBACS_-mohkbk,4498
 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
@@ -8,8 +8,9 @@ notionary/elements/audio_element.py,sha256=7bEpFl9jA6S1UZlEXsmFzEUVoViEp1o_7zZIC
 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=Zy5l8bsX2R1QBgmCZDM_tkxzSXylHABshKY8r0kNBBo,5853
-notionary/elements/divider_element.py,sha256=0e10YK-CC8uGuL7921dEIjeJK9ha-WhRIYRf2fFuxVQ,2211
+notionary/elements/code_block_element.py,sha256=YHOiV2eQIe7gbsOnrsQnztomTZ-eP3HRHsonzrj3Tt8,7529
+notionary/elements/column_element.py,sha256=lMVRKXndOuN6lsBMlkgZ-11uuoEFLtUFedwrPAswL1E,7555
+notionary/elements/divider_element.py,sha256=Kt2oJJQD3zKyWSQ3JOG0nUgYqJRodMO4UVy7EXixxes,2330
 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
@@ -24,20 +25,20 @@ notionary/elements/todo_element.py,sha256=ND3oOzSnd0l1AUGTcG2NiHW50ZbI4-atjtNorL
 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=Wnob3PbgzVAoXBW0Eon1KzX4aD4d36KeaDe_uYIKFnU,9311
+notionary/elements/registry/block_registry.py,sha256=T2yKRyzsdC9OSWdsiG-AI2T60SmtaR-7QaM6lOz0qrw,5028
+notionary/elements/registry/block_registry_builder.py,sha256=KU1Qh3qaB1lMrSBj1iyi8Hkx1h0HfxtajmkXZhMb68k,9545
 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=FMAasQP20S12J_KMdMlNpcHHwxFKX2YtbE4Q9xn-ruQ,1213
 notionary/models/notion_page_response.py,sha256=r4fwMwwDocj92JdbSmyrzIqBKsnEaz4aDUiPabrg9BM,1762
-notionary/page/markdown_to_notion_converter.py,sha256=EuqUGNv2HZu67INOnGheeJkt7WHTWGuLnhEG72_Wv5Y,15833
+notionary/page/markdown_to_notion_converter.py,sha256=QYlxotQoBK5Ruj7UvfYfMdbsylQCMw7OX6Ng5CyMeVo,17097
 notionary/page/notion_page.py,sha256=NDxAJaNk4tlKUrenhKBdnuvjlVgnxC0Z6fprf2LyNeE,18046
 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=i6y4Q3_5EIzsd6HRgO3G-v1STZs1060OJe5DFkZi-QI,2290
-notionary/page/content/page_content_writer.py,sha256=czBzNCGcwdpqNLSQPyna1s8Y7pjyPzDgJC3UUK5PLGA,3793
+notionary/page/content/page_content_retriever.py,sha256=f8IU1CIfSTTT07m72-vgpUr_VOCsisqqFHQ1JeOhb3g,2222
+notionary/page/content/page_content_writer.py,sha256=ZLqDBiYdkdCjgZgucoBGiUH8qM46zltIbJqu1aBqXzw,4425
 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
@@ -49,12 +50,12 @@ notionary/page/relations/notion_page_relation_manager.py,sha256=tfkvLHClaYel_uEa
 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=0hD2DZDDjQ3ZKHPvZnDKpUs6Puq5O_E2IGW1te1R6v4,4751
+notionary/prompting/markdown_syntax_prompt_generator.py,sha256=WHTpftR7LdY-yA54TlicVwt6R-mhZ2OpUFmNKaCSG0I,5096
 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.5.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
-notionary-0.2.5.dist-info/METADATA,sha256=QT7PBlbv3Qu6BqzamzrxZnf28zwZp43_IgBa4F3uCwo,8374
-notionary-0.2.5.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-notionary-0.2.5.dist-info/top_level.txt,sha256=fhONa6BMHQXqthx5PanWGbPL0b8rdFqhrJKVLf_adSs,10
-notionary-0.2.5.dist-info/RECORD,,
+notionary-0.2.7.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
+notionary-0.2.7.dist-info/METADATA,sha256=KZbjwvx9HJQ2BCg5RnRgZrhOGa43r8QMOWF2yKwY1uA,7116
+notionary-0.2.7.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+notionary-0.2.7.dist-info/top_level.txt,sha256=fhONa6BMHQXqthx5PanWGbPL0b8rdFqhrJKVLf_adSs,10
+notionary-0.2.7.dist-info/RECORD,,

notionary-0.2.5.dist-info/METADATA

@@ -1,256 +0,0 @@
-Metadata-Version: 2.4
-Name: notionary
-Version: 0.2.5
-Summary: A toolkit to convert between Markdown and Notion blocks
-Home-page: https://github.com/mathisarends/notionary
-Author: Mathis Arends
-Author-email: mathisarends27@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >=3.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
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Notionary 📝
-
-[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/downloads/)
-[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
-
-**Notionary** is a powerful Python library for interacting with the Notion API, making it easy to create, update, and manage Notion pages and databases programmatically with a clean, intuitive interface. It's specifically designed to be the foundation for AI-driven Notion content generation.
-
-## Features
-
-- **Rich Markdown Support**: Create Notion pages using intuitive Markdown syntax with custom extensions
-- **Dynamic Database Operations**: Create, update, and query database entries with schema auto-detection
-- **Extensible Block Registry**: Add, customize, or remove Notion block elements with a flexible registry pattern
-- **LLM-Ready Prompts**: Generate system prompts explaining Markdown syntax for LLMs to create Notion content
-- **Async-First Design**: Built for modern Python with full async/await support
-- **Schema-Based Validation**: Automatic property validation based on database schemas
-- **Intelligent Content Conversion**: Bidirectional conversion between Markdown and Notion blocks
-
-## Installation
-
-```bash
-pip install notionary
-```
-
-## Custom Markdown Syntax
-
-Notionary extends standard Markdown with special syntax to support Notion-specific features:
-
-### Text Formatting
-
-- Standard Markdown: `**bold**`, `*italic*`, `~~strikethrough~~`, `` `code` ``
-- Highlights: `==highlighted text==`, `==red:warning==`, `==blue:note==`
-
-### Block Elements
-
-#### Callouts
-
-```markdown
-!> [💡] This is a default callout with the light bulb emoji  
-!> [🔔] This is a callout with a bell emoji  
-!> {blue_background} [💧] This is a blue callout with a water drop emoji  
-!> {yellow_background} [⚠️] Warning: This is an important note
-```
-
-#### Toggles
-
-```markdown
-+++ How to use NotionPageManager
-
-1. Initialize with NotionPageManager
-2. Update metadata with set_title(), set_page_icon(), etc.
-3. Add content with replace_content() or append_markdown()
-```
-
-#### Bookmarks
-
-```markdown
-[bookmark](https://notion.so "Notion Homepage" "Your connected workspace")
-```
-
-#### Multi-Column Layouts
-
-```markdown
-::: columns
-::: column
-Content for first column
-:::
-::: column
-Content for second column
-:::
-:::
-```
-
-And more:
-
-- Tables with standard Markdown syntax
-- Code blocks with syntax highlighting
-- To-do lists with `- [ ]` and `- [x]`
-- Block quotes with `>`
-
-## Database Management
-
-Notionary makes it easy to work with Notion databases, automatically handling schema detection and property conversion:
-
-```python
-import asyncio
-from notionary import NotionDatabaseFactory
-
-async def main():
-    # Find database by name with fuzzy matching
-    db_manager = await NotionDatabaseFactory.from_database_name("Projects")
-
-    # Create a new page with properties
-    properties = {
-        "Title": "Created via Notionary",
-        "Status": "In Progress",
-        "Priority": "High"
-    }
-
-    page = await db_manager.create_blank_page()
-
-    # Set page content with rich Markdown
-    await page.set_title("My New Project")
-    await page.set_page_icon(emoji="🚀")
-
-    markdown = """
-    # Project Overview
-
-    !> [💡] This page was created programmatically using Notionary.
-
-    ## Tasks
-    - [ ] Define project scope
-    - [ ] Create timeline
-    - [ ] Assign resources
-
-    +++ Implementation Details
-      This project will use our standard architecture with custom extensions.
-    """
-
-    await page.replace_content(markdown)
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-
-## Page Content Management
-
-Create rich Notion pages using enhanced Markdown:
-
-```python
-from notionary import NotionPage
-
-async def create_rich_page():
-    url = "https://www.notion.so/Your-Page-1cd389d57bd381e58be9d35ce24adf3d"
-    page_manager = NotionPage(url=url)
-
-    await page_manager.set_title("Notionary Demo")
-    await page_manager.set_page_icon(emoji="✨")
-    await page_manager.set_page_cover("https://images.unsplash.com/photo-1555066931-4365d14bab8c")
-
-    markdown = '''
-    # Notionary Rich Content Demo
-
-    !> [💡] This page was created with Notionary's custom Markdown syntax.
-
-    ## Features
-    - Easy-to-use Python API
-    - **Rich** Markdown support
-    - Async functionality
-
-    +++ Implementation Details
-      Notionary uses a custom converter to transform Markdown into Notion blocks.
-      This makes it easy to create rich content programmatically.
-    '''
-
-    await page_manager.replace_content(markdown)
-```
-
-## Block Registry & Builder
-
-Notionary uses a flexible registry pattern with a builder to customize which Notion elements are supported, allowing programmatic creation of complex UI layouts that were previously only possible through Notion's UI:
-
-```python
-from notionary import NotionPage
-from notionary.elements.block_element_registry_builder import BlockElementRegistryBuilder
-
-# Create a registry with standard Notion elements
-registry = BlockElementRegistryBuilder.create_full_registry()
-
-# Or build a custom registry with only the elements you need
-custom_registry = (
-    BlockElementRegistryBuilder()
-    .with_headings()
-    .with_callouts()
-    .with_toggles()
-    .with_lists()
-    .with_tables()
-    .with_paragraphs()
-    .build()
-)
-
-# Apply this registry to a page to enable custom Markdown support
-page = NotionPage(url="https://www.notion.so/your-page-url")
-page.block_registry = custom_registry
-
-# Now your page supports exactly the elements you've defined
-await page.replace_content("# Custom heading with only selected elements")
-```
-
-This registry approach gives you granular control over which Notion UI elements can be created through Markdown, making it possible to programmatically construct any page layout that would normally require manual UI interaction.
-
-## AI-Ready LLM Prompt Generation
-
-Notionary can automatically generate comprehensive system prompts for LLMs to understand Notion's custom Markdown syntax:
-
-```python
-from notionary.elements.block_element_registry_builder import BlockElementRegistryBuilder
-
-registry = BlockElementRegistryBuilder.create_full_registry()
-llm_system_prompt = registry.generate_llm_prompt()
-
-# Use this prompt with your LLM to generate Notion-compatible Markdown
-print(llm_system_prompt)
-```
-
-This makes Notionary the perfect foundation for AI-driven Notion content generation, enabling LLMs to create properly formatted Notion pages.
-
-## Examples
-
-See the [examples folder](examples/) for more comprehensive demonstrations:
-
-- [Database discovery and querying](examples/database_discovery_example.py)
-- [Rich page creation with Markdown](examples/page_example.py)
-- [Database factory usage](examples/database_factory_example.py)
-- [Page lookup and access](examples/page_factory_by_url_example.py)
-- [Iterating through database entries](examples/iter_database_example.py)
-
-## Perfect for AI Agents and Automation
-
-- **LLM Integration**: Generate Notion-compatible content with LLMs using the system prompt generator
-- **Dynamic Content Generation**: AI agents can generate content in Markdown and render it as Notion pages
-- **Schema-Aware Operations**: Automatically validate and format properties
-- **Simplified API**: Easier integration with AI workflows
-
-## License
-
-MIT
-
-## Contributing
-
-Contributions welcome — feel free to submit a pull request!