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

notionary/elements/qoute_element.py

@@ -1,28 +1,11 @@
 import re
 from typing import Dict, Any, Optional, List, Tuple
-from typing_extensions import override
-
 from notionary.elements.notion_block_element import NotionBlockElement
+from notionary.elements.prompts.element_prompt_content import ElementPromptContent
 
 
 class QuoteElement(NotionBlockElement):
-    """Class for converting between Markdown blockquotes and Notion quote blocks with background color support."""
-
-    # Mapping von Markdown-Farbnamen zu Notion-Farbnamen
-    COLOR_MAPPING = {
-        "gray": "gray_background",
-        "brown": "brown_background",
-        "orange": "orange_background",
-        "yellow": "yellow_background",
-        "green": "green_background",
-        "blue": "blue_background",
-        "purple": "purple_background",
-        "pink": "pink_background",
-        "red": "red_background",
-    }
-
-    # Umgekehrtes Mapping für die Rückkonvertierung
-    REVERSE_COLOR_MAPPING = {v: k for k, v in COLOR_MAPPING.items()}
+    """Class for converting between Markdown blockquotes and Notion quote blocks."""
 
     @staticmethod
     def find_matches(text: str) -> List[Tuple[int, int, Dict[str, Any]]]:
@@ -87,10 +70,9 @@ class QuoteElement(NotionBlockElement):
 
         return matches
 
-    @override
     @staticmethod
     def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
-        """Convert markdown blockquote to Notion block with background color support."""
+        """Convert markdown blockquote to Notion block."""
         if not text:
             return None
 
@@ -103,40 +85,12 @@ class QuoteElement(NotionBlockElement):
         # Extract quote content
         lines = text.split("\n")
         quote_lines = []
-        color = "default"  # Standardfarbe
 
-        # Überprüfen, ob der erste Nicht-Leerzeichen-Inhalt eine Farbangabe ist
-        first_line = None
-        for line in lines:
-            quote_match = quote_pattern.match(line)
-            if quote_match and quote_match.group(1).strip():
-                first_line = quote_match.group(1).strip()
-                break
-
-        # Farbangabe in eckigen Klammern prüfen
-        if first_line:
-            color_match = re.match(r"^\[background:(\w+)\]\s*(.*)", first_line)
-            if color_match:
-                potential_color = color_match.group(1).lower()
-                if potential_color in QuoteElement.COLOR_MAPPING:
-                    color = QuoteElement.COLOR_MAPPING[potential_color]
-                    # Erste Zeile ohne Farbangabe neu hinzufügen
-                    first_line = color_match.group(2)
-
-        # Inhalte extrahieren
-        processing_first_color_line = True
+        # Extract content from each line
         for line in lines:
             quote_match = quote_pattern.match(line)
             if quote_match:
                 content = quote_match.group(1)
-                # Farbangabe in der ersten Zeile entfernen
-                if (
-                    processing_first_color_line
-                    and content.strip()
-                    and re.match(r"^\[background:(\w+)\]", content.strip())
-                ):
-                    content = re.sub(r"^\[background:(\w+)\]\s*", "", content)
-                    processing_first_color_line = False
                 quote_lines.append(content)
             elif not line.strip() and quote_lines:
                 # Allow empty lines within the quote
@@ -147,20 +101,17 @@ class QuoteElement(NotionBlockElement):
 
         quote_content = "\n".join(quote_lines).strip()
 
-        # Create rich_text elements directly
         rich_text = [{"type": "text", "text": {"content": quote_content}}]
 
-        return {"type": "quote", "quote": {"rich_text": rich_text, "color": color}}
+        return {"type": "quote", "quote": {"rich_text": rich_text, "color": "default"}}
 
-    @override
     @staticmethod
     def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion quote block to markdown with background color support."""
+        """Convert Notion quote block to markdown."""
         if block.get("type") != "quote":
             return None
 
         rich_text = block.get("quote", {}).get("rich_text", [])
-        color = block.get("quote", {}).get("color", "default")
 
         # Extract the text content
         content = QuoteElement._extract_text_content(rich_text)
@@ -169,33 +120,23 @@ class QuoteElement(NotionBlockElement):
         lines = content.split("\n")
         formatted_lines = []
 
-        # Füge die Farbinformation zur ersten Zeile hinzu, falls nicht default
-        if color != "default" and color in QuoteElement.REVERSE_COLOR_MAPPING:
-            markdown_color = QuoteElement.REVERSE_COLOR_MAPPING.get(color)
-            first_line = lines[0] if lines else ""
-            formatted_lines.append(f"> [background:{markdown_color}] {first_line}")
-            lines = lines[1:] if len(lines) > 1 else []
-
-        # Füge die restlichen Zeilen hinzu
+        # Add each line with blockquote prefix
         for line in lines:
             formatted_lines.append(f"> {line}")
 
         return "\n".join(formatted_lines)
 
-    @override
     @staticmethod
     def match_markdown(text: str) -> bool:
         """Check if this element can handle the given markdown text."""
         quote_pattern = re.compile(r"^\s*>\s?(.*)", re.MULTILINE)
         return bool(quote_pattern.search(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") == "quote"
 
-    @override
     @staticmethod
     def is_multiline() -> bool:
         """Blockquotes can span multiple lines."""
@@ -212,31 +153,21 @@ class QuoteElement(NotionBlockElement):
                 result += text_obj.get("plain_text", "")
         return result
 
-    @override
     @classmethod
-    def get_llm_prompt_content(cls) -> dict:
-        """Returns information for LLM prompts about this element."""
+    def get_llm_prompt_content(cls) -> ElementPromptContent:
+        """
+        Returns structured LLM prompt metadata for the quote element.
+        """
         return {
-            "description": "Creates blockquotes that visually distinguish quoted text with optional background colors.",
-            "when_to_use": "Use blockquotes for quoting external sources, highlighting important statements, or creating visual emphasis for key information.",
-            "syntax": [
-                "> Text - Simple blockquote",
-                "> [background:color] Text - Blockquote with colored background",
-            ],
-            "color_options": [
-                "gray",
-                "brown",
-                "orange",
-                "yellow",
-                "green",
-                "blue",
-                "purple",
-                "pink",
-                "red",
-            ],
+            "description": "Creates blockquotes that visually distinguish quoted text.",
+            "when_to_use": (
+                "Use blockquotes for quoting external sources, highlighting important statements, "
+                "or creating visual emphasis for key information."
+            ),
+            "syntax": "> Quoted text",
             "examples": [
-                "> This is a simple blockquote without any color",
-                "> [background:blue] This is a blockquote with blue background",
-                "> Multi-line quotes\n> continue like this\n> across several lines",
+                "> This is a simple blockquote",
+                "> This is a multi-line quote\n> that continues on the next line",
+                "> Important note:\n> This quote spans\n> multiple lines.",
             ],
         }

notionary/elements/registry/block_element_registry.py

@@ -0,0 +1,90 @@
+from typing import Dict, Any, Optional, List, Type
+
+from notionary.elements.notion_block_element import NotionBlockElement
+from notionary.elements.prompts.synthax_prompt_builder import (
+    MarkdownSyntaxPromptBuilder,
+)
+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.
+        """
+        self._elements = []
+
+        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.
+        """
+        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.
+        """
+        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)

notionary/elements/{block_element_registry_builder.py → registry/block_element_registry_builder.py}

@@ -3,10 +3,12 @@ from typing import List, Type
 from collections import OrderedDict
 
 from notionary.elements.audio_element import AudioElement
+from notionary.elements.bulleted_list_element import BulletedListElement
 from notionary.elements.embed_element import EmbedElement
 from notionary.elements.mention_element import MentionElement
 from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.elements.block_element_registry import (
+from notionary.elements.numbered_list_element import NumberedListElement
+from notionary.elements.registry.block_element_registry import (
     BlockElementRegistry,
 )
 
@@ -17,10 +19,6 @@ from notionary.elements.code_block_element import CodeBlockElement
 from notionary.elements.divider_element import DividerElement
 from notionary.elements.table_element import TableElement
 from notionary.elements.todo_lists import TodoElement
-from notionary.elements.list_element import (
-    BulletedListElement,
-    NumberedListElement,
-)
 from notionary.elements.qoute_element import QuoteElement
 from notionary.elements.image_element import ImageElement
 from notionary.elements.video_element import VideoElement
@@ -42,33 +40,9 @@ class BlockElementRegistryBuilder:
         self._elements = OrderedDict()
 
     @classmethod
-    def start_empty(cls) -> BlockElementRegistryBuilder:
-        """
-        Start with a completely empty registry builder.
-
-        Returns:
-            A new builder instance with no elements
-        """
-        return cls()
-
-    @classmethod
-    def start_minimal(cls) -> BlockElementRegistryBuilder:
-        """
-        Start with a minimal set of essential elements.
-
-        Returns:
-            A new builder instance with basic elements
-        """
-        builder = cls()
-        return builder.with_headings().with_lists().with_paragraphs()
-
-    @classmethod
-    def start_standard(cls) -> BlockElementRegistryBuilder:
+    def create_full_registry(cls) -> BlockElementRegistry:
         """
         Start with all standard elements in recommended order.
-
-        Returns:
-            A new builder instance with all standard elements
         """
         builder = cls()
         return (
@@ -78,7 +52,8 @@ class BlockElementRegistryBuilder:
             .with_dividers()
             .with_tables()
             .with_columns()
-            .with_lists()
+            .with_bulleted_list()
+            .with_numberd_list()
             .with_toggles()
             .with_quotes()
             .with_todos()
@@ -89,9 +64,7 @@ class BlockElementRegistryBuilder:
             .with_audio()
             .with_mention()
             .with_paragraphs()
-        )
-
-    # Element manipulation methods
+        ).build()
 
     def add_element(
         self, element_class: Type[NotionBlockElement]
@@ -168,153 +141,108 @@ class BlockElementRegistryBuilder:
     def with_paragraphs(self) -> BlockElementRegistryBuilder:
         """
         Add support for paragraph elements.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(ParagraphElement)
 
     def with_headings(self) -> BlockElementRegistryBuilder:
         """
         Add support for heading elements.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(HeadingElement)
 
     def with_callouts(self) -> BlockElementRegistryBuilder:
         """
         Add support for callout elements.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(CalloutElement)
 
     def with_code(self) -> BlockElementRegistryBuilder:
         """
         Add support for code blocks.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(CodeBlockElement)
 
     def with_dividers(self) -> BlockElementRegistryBuilder:
         """
         Add support for divider elements.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(DividerElement)
 
     def with_tables(self) -> BlockElementRegistryBuilder:
         """
         Add support for tables.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(TableElement)
 
     def with_columns(self) -> BlockElementRegistryBuilder:
         """
         Add support for column elements.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(ColumnElement)
 
-    def with_lists(self) -> BlockElementRegistryBuilder:
+    def with_bulleted_list(self) -> BlockElementRegistryBuilder:
+        """
+        Add support for bulleted list elements (unordered lists).
         """
-        Add support for list elements.
+        return self.add_element(BulletedListElement)
 
-        Returns:
-            Self for method chaining
+    def with_numberd_list(self) -> BlockElementRegistryBuilder:
+        """
+        Add support for numbered list elements (ordered lists).
         """
-        return self.add_element(BulletedListElement).add_element(NumberedListElement)
+        return self.add_element(NumberedListElement)
 
     def with_toggles(self) -> BlockElementRegistryBuilder:
         """
         Add support for toggle elements.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(ToggleElement)
 
     def with_quotes(self) -> BlockElementRegistryBuilder:
         """
         Add support for quote elements.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(QuoteElement)
 
     def with_todos(self) -> BlockElementRegistryBuilder:
         """
         Add support for todo elements.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(TodoElement)
 
     def with_bookmarks(self) -> BlockElementRegistryBuilder:
         """
         Add support for bookmark elements.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(BookmarkElement)
 
     def with_images(self) -> BlockElementRegistryBuilder:
         """
         Add support for image elements.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(ImageElement)
 
     def with_videos(self) -> BlockElementRegistryBuilder:
         """
         Add support for video elements.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(VideoElement)
 
     def with_embeds(self) -> BlockElementRegistryBuilder:
         """
         Add support for embed elements.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(EmbedElement)
 
     def with_audio(self) -> BlockElementRegistryBuilder:
         """
         Add support for audio elements.
-
-        Returns:
-            Self for method chaining
         """
         return self.add_element(AudioElement)
 
     def with_media_support(self) -> BlockElementRegistryBuilder:
         """
         Add support for media elements (images, videos, audio).
-
-        Returns:
-            Self for method chaining
         """
         return self.with_images().with_videos().with_audio()
 
@@ -333,10 +261,8 @@ class BlockElementRegistryBuilder:
             A configured BlockElementRegistry instance
         """
         if ParagraphElement.__name__ not in self._elements:
-            # Add paragraph as fallback if not present
             self.add_element(ParagraphElement)
         else:
-            # Ensure it's at the end
             self._ensure_paragraph_at_end()
 
         registry = BlockElementRegistry()
@@ -346,38 +272,3 @@ class BlockElementRegistryBuilder:
             registry.register(element_class)
 
         return registry
-
-    @classmethod
-    def create_standard_registry(cls) -> BlockElementRegistry:
-        """
-        Factory method to directly create a standard registry.
-
-        Returns:
-            A fully configured registry instance
-        """
-        return cls.start_standard().build()
-
-    @classmethod
-    def create_minimal_registry(cls) -> BlockElementRegistry:
-        """
-        Factory method to directly create a minimal registry.
-
-        Returns:
-            A minimal registry instance
-        """
-        return cls.start_minimal().build()
-
-    @classmethod
-    def create_custom_registry(
-        cls, element_classes: List[Type[NotionBlockElement]]
-    ) -> BlockElementRegistry:
-        """
-        Factory method to directly create a custom registry.
-
-        Args:
-            element_classes: List of element classes to register
-
-        Returns:
-            A custom configured registry instance
-        """
-        return cls().add_elements(element_classes).build()

notionary/elements/table_element.py

@@ -1,10 +1,8 @@
-# File: elements/tables.py
-
-from typing import Dict, Any, Optional, List, Tuple
-from typing_extensions import override
 import re
+from typing import Dict, Any, Optional, List, Tuple
 from notionary.elements.notion_block_element import NotionBlockElement
 from notionary.elements.text_inline_formatter import TextInlineFormatter
+from notionary.elements.prompts.element_prompt_content import ElementPromptContent
 
 
 class TableElement(NotionBlockElement):
@@ -20,11 +18,9 @@ class TableElement(NotionBlockElement):
     The second line with dashes and optional colons defines column alignment.
     """
 
-    # Patterns for detecting Markdown tables
     ROW_PATTERN = re.compile(r"^\s*\|(.+)\|\s*$")
     SEPARATOR_PATTERN = re.compile(r"^\s*\|([\s\-:|]+)\|\s*$")
 
-    @override
     @staticmethod
     def match_markdown(text: str) -> bool:
         """Check if text contains a markdown table."""
@@ -43,13 +39,11 @@ class TableElement(NotionBlockElement):
 
         return False
 
-    @override
     @staticmethod
     def match_notion(block: Dict[str, Any]) -> bool:
         """Check if block is a Notion table."""
         return block.get("type") == "table"
 
-    @override
     @staticmethod
     def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
         """Convert markdown table to Notion table block."""
@@ -82,7 +76,6 @@ class TableElement(NotionBlockElement):
             },
         }
 
-    @override
     @staticmethod
     def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
         """Convert Notion table block to markdown table."""
@@ -145,7 +138,6 @@ class TableElement(NotionBlockElement):
 
         return "\n".join(table_rows)
 
-    @override
     @staticmethod
     def is_multiline() -> bool:
         """Indicates if this element handles content that spans multiple lines."""
@@ -289,16 +281,12 @@ class TableElement(NotionBlockElement):
         return position
 
     @classmethod
-    def get_llm_prompt_content(cls) -> dict:
+    def get_llm_prompt_content(cls) -> ElementPromptContent:
         """Returns information for LLM prompts about this element."""
         return {
             "description": "Creates formatted tables with rows and columns for structured data.",
             "when_to_use": "Use tables to organize and present structured data in a grid format, making information easier to compare and analyze. Tables are ideal for data sets, comparison charts, pricing information, or any content that benefits from columnar organization.",
-            "notes": [
-                "The header row is required and will be displayed differently in Notion",
-                "The separator row with dashes is required to define the table structure",
-                "Table cells support inline formatting such as **bold** and *italic*",
-            ],
+            "syntax": "| Header 1 | Header 2 | Header 3 |\n| -------- | -------- | -------- |\n| Cell 1   | Cell 2   | Cell 3   |",
             "examples": [
                 "| Product | Price | Stock |\n| ------- | ----- | ----- |\n| Widget A | $10.99 | 42 |\n| Widget B | $14.99 | 27 |",
                 "| Name | Role | Department |\n| ---- | ---- | ---------- |\n| John Smith | Manager | Marketing |\n| Jane Doe | Director | Sales |",