notionary 0.2.16__py3-none-any.whl → 0.2.18__py3-none-any.whl

notionary/blocks/{numbered_list_element.py → numbered_list/numbered_list_element.py}

@@ -1,15 +1,19 @@
 import re
-from typing import Dict, Any, Optional
+from typing import Any, Optional
 from notionary.blocks import NotionBlockElement
-from notionary.blocks import ElementPromptContent, ElementPromptBuilder
-from notionary.blocks.text_inline_formatter import TextInlineFormatter
+from notionary.blocks import (
+    ElementPromptContent,
+    ElementPromptBuilder,
+    NotionBlockResult,
+)
+from notionary.blocks.shared.text_inline_formatter import TextInlineFormatter
 
 
 class NumberedListElement(NotionBlockElement):
     """Class for converting between Markdown numbered lists and Notion numbered list items."""
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
+    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
         """Convert markdown numbered list item to Notion block."""
         pattern = re.compile(r"^\s*(\d+)\.\s+(.+)$")
         numbered_match = pattern.match(text)
@@ -27,7 +31,7 @@ class NumberedListElement(NotionBlockElement):
         }
 
     @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
+    def notion_to_markdown(cls, block: dict[str, Any]) -> Optional[str]:
         """Convert Notion numbered list item block to markdown."""
         if block.get("type") != "numbered_list_item":
             return None
@@ -44,7 +48,7 @@ class NumberedListElement(NotionBlockElement):
         return bool(pattern.match(text))
 
     @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
+    def match_notion(cls, block: dict[str, Any]) -> bool:
         """Check if this element can handle the given Notion block."""
         return block.get("type") == "numbered_list_item"
 

notionary/blocks/numbered_list/numbered_list_markdown_node.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+from pydantic import BaseModel
+from notionary.blocks.markdown_node import MarkdownNode
+
+
+class NumberedListMarkdownBlockParams(BaseModel):
+    texts: list[str]
+
+
+class NumberedListMarkdownNode(MarkdownNode):
+    """
+    Programmatic interface for creating Markdown numbered list items.
+    Example:
+    1. First step
+    2. Second step
+    3. Third step
+    """
+
+    def __init__(self, texts: list[str]):
+        self.texts = texts
+
+    @classmethod
+    def from_params(
+        cls, params: NumberedListMarkdownBlockParams
+    ) -> NumberedListMarkdownNode:
+        return cls(texts=params.texts)
+
+    def to_markdown(self) -> str:
+        return "\n".join(f"{i + 1}. {text}" for i, text in enumerate(self.texts))

notionary/blocks/paragraph/__init__.py

@@ -0,0 +1,7 @@
+from .paragraph_element import ParagraphElement
+from .paragraph_markdown_node import ParagraphMarkdownNode
+
+__all__ = [
+    "ParagraphElement",
+    "ParagraphMarkdownNode",
+]

notionary/blocks/{paragraph_element.py → paragraph/paragraph_element.py}

@@ -1,8 +1,12 @@
 from typing import Dict, Any, Optional
 
 from notionary.blocks import NotionBlockElement
-from notionary.blocks import ElementPromptContent, ElementPromptBuilder
-from notionary.blocks.text_inline_formatter import TextInlineFormatter
+from notionary.blocks import (
+    ElementPromptContent,
+    ElementPromptBuilder,
+    NotionBlockResult,
+)
+from notionary.blocks.shared.text_inline_formatter import TextInlineFormatter
 
 
 class ParagraphElement(NotionBlockElement):
@@ -23,7 +27,7 @@ class ParagraphElement(NotionBlockElement):
         return block.get("type") == "paragraph"
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
+    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
         """Convert markdown paragraph to Notion paragraph block."""
         if not text.strip():
             return None

notionary/blocks/paragraph/paragraph_markdown_node.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+from notionary.blocks.markdown_node import MarkdownNode
+
+
+class ParagraphMarkdownBlockParams(BaseModel):
+    text: str
+
+
+class ParagraphMarkdownNode(MarkdownNode):
+    """
+    Programmatic interface for creating Markdown paragraphs.
+    Paragraphs are standard text without special block formatting.
+    """
+
+    def __init__(self, text: str):
+        self.text = text
+
+    @classmethod
+    def from_params(cls, params: ParagraphMarkdownBlockParams) -> ParagraphMarkdownNode:
+        return cls(text=params.text)
+
+    def to_markdown(self) -> str:
+        return self.text

notionary/blocks/quote/__init__.py

@@ -0,0 +1,7 @@
+from .quote_element import QuoteElement
+from .quote_markdown_node import QuoteMarkdownNode
+
+__all__ = [
+    "QuoteElement",
+    "QuoteMarkdownNode",
+]

notionary/blocks/quote/quote_element.py

@@ -0,0 +1,92 @@
+import re
+from typing import Dict, Any, Optional, List, Tuple
+
+from notionary.blocks import NotionBlockElement, NotionBlockResult
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+
+class QuoteElement(NotionBlockElement):
+    """
+    Handles conversion between Markdown quotes and Notion quote blocks.
+    Markdown quote syntax:
+    - [quote](Simple quote text)
+    """
+
+    # Einzeilig, kein Author, kein Anführungszeichen-Kram mehr!
+    PATTERN = re.compile(r'^\[quote\]\(([^\n\r]+)\)$')
+
+    @classmethod
+    def match_markdown(cls, text: str) -> bool:
+        m = cls.PATTERN.match(text.strip())
+        # Nur gültig, wenn etwas nicht-leeres drinsteht
+        return bool(m and m.group(1).strip())
+
+    @classmethod
+    def match_notion(cls, block: Dict[str, Any]) -> bool:
+        return block.get("type") == "quote"
+
+    @classmethod
+    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
+        if not text:
+            return None
+
+        match = cls.PATTERN.match(text.strip())
+        if not match:
+            return None
+
+        content = match.group(1).strip()
+        if not content:
+            return None
+
+        rich_text = [{"type": "text", "text": {"content": content}}]
+        return {"type": "quote", "quote": {"rich_text": rich_text, "color": "default"}}
+
+    @classmethod
+    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
+        if block.get("type") != "quote":
+            return None
+
+        rich_text = block.get("quote", {}).get("rich_text", [])
+        content = cls._extract_text_content(rich_text)
+        if not content.strip():
+            return None
+
+        return f"[quote]({content.strip()})"
+
+    @classmethod
+    def find_matches(cls, text: str) -> List[Tuple[int, int, Dict[str, Any]]]:
+        matches = []
+        for match in re.finditer(r"^\[quote\]\([^\n\r]+\)$", text, re.MULTILINE):
+            candidate = match.group(0)
+            block = cls.markdown_to_notion(candidate)
+            if block:
+                matches.append((match.start(), match.end(), block))
+        return matches
+
+    @classmethod
+    def is_multiline(cls) -> bool:
+        return False
+
+    @classmethod
+    def _extract_text_content(cls, rich_text: List[Dict[str, Any]]) -> str:
+        return "".join(
+            t.get("text", {}).get("content", "")
+            for t in rich_text
+            if t.get("type") == "text"
+        )
+
+    @classmethod
+    def get_llm_prompt_content(cls) -> ElementPromptContent:
+        return (
+            ElementPromptBuilder()
+            .with_description("Creates blockquotes that visually distinguish quoted text.")
+            .with_usage_guidelines(
+                "Use quotes for quoting external sources, highlighting important statements, "
+                "or creating visual emphasis for key information."
+            )
+            .with_syntax('[quote](Quote text)')
+            .with_examples([
+                "[quote](This is a simple blockquote)",
+                "[quote](Knowledge is power)",
+            ])
+            .build()
+        )

notionary/blocks/quote/quote_markdown_node.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+from notionary.blocks.markdown_node import MarkdownNode
+
+class QuoteMarkdownBlockParams(BaseModel):
+    text: str
+
+class QuoteMarkdownNode(MarkdownNode):
+    """
+    Programmatic interface for creating Notion-style quote blocks.
+    Example: [quote](This is a quote)
+    """
+
+    def __init__(self, text: str):
+        self.text = text
+
+    @classmethod
+    def from_params(cls, params: QuoteMarkdownBlockParams) -> QuoteMarkdownNode:
+        return cls(text=params.text)
+
+    def to_markdown(self) -> str:
+        return f"[quote]({self.text})"

notionary/blocks/registry/block_registry.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 from typing import Dict, Any, Optional, List, Set, Type
 
-from notionary.blocks.notion_block_element import NotionBlockElement
+from notionary.blocks import NotionBlockElement
 from notionary.page.markdown_syntax_prompt_generator import (
     MarkdownSyntaxPromptGenerator,
 )
-from notionary.blocks.text_inline_formatter import TextInlineFormatter
+from notionary.blocks import TextInlineFormatter
 
 from notionary.blocks import NotionBlockElement
 from notionary.telemetry import (
@@ -25,7 +25,6 @@ class BlockRegistry:
 
         Args:
             elements: Initial elements to register
-            builder: The builder that created this registry (optional)
         """
         self._elements: List[NotionBlockElement] = []
         self._element_types: Set[Type[NotionBlockElement]] = set()
@@ -36,6 +35,21 @@ class BlockRegistry:
 
         self.telemetry = ProductTelemetry()
 
+    @classmethod
+    def create_registry(cls) -> BlockRegistry:
+        """
+        Create a registry with all standard elements in recommended order.
+
+        This uses the BlockRegistryBuilder internally to construct a complete
+        registry with all available block types.
+
+        Returns:
+            BlockRegistry: A fully configured registry with all standard elements
+        """
+        from notionary.blocks import BlockRegistryBuilder
+
+        return BlockRegistryBuilder.create_registry()
+
     def register(self, element_class: Type[NotionBlockElement]) -> bool:
         """
         Register an element class.

notionary/blocks/registry/block_registry_builder.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import List, Type, TYPE_CHECKING
+from typing import Type, TYPE_CHECKING, Self
 from collections import OrderedDict
 
 from notionary.blocks import (
@@ -7,7 +7,7 @@ from notionary.blocks import (
     AudioElement,
     BulletedListElement,
     CalloutElement,
-    CodeBlockElement,
+    CodeElement,
     ColumnElement,
     DividerElement,
     EmbedElement,
@@ -42,7 +42,7 @@ class BlockRegistryBuilder:
         self._elements = OrderedDict()
 
     @classmethod
-    def create_full_registry(cls) -> BlockRegistry:
+    def create_registry(cls) -> BlockRegistry:
         """
         Start with all standard elements in recommended order.
         """
@@ -69,57 +69,7 @@ class BlockRegistryBuilder:
             .with_toggleable_heading_element()
         ).build()
 
-    @classmethod
-    def create_minimal_registry(cls) -> BlockRegistry:
-        """
-        Create a minimal registry with just essential text elements.
-        Suitable for basic note-taking.
-        """
-        builder = cls()
-        return (
-            builder.with_paragraphs()
-            .with_headings()
-            .with_bulleted_list()
-            .with_numbered_list()
-        ).build()
-
-    def add_element(
-        self, element_class: Type[NotionBlockElement]
-    ) -> BlockRegistryBuilder:
-        """
-        Add an element class to the registry configuration.
-        If the element already exists, it's moved to the end.
-
-        Args:
-            element_class: The element class to add
-
-        Returns:
-            Self for method chaining
-        """
-        self._elements.pop(element_class.__name__, None)
-        self._elements[element_class.__name__] = element_class
-
-        return self
-
-    def add_elements(
-        self, element_classes: List[Type[NotionBlockElement]]
-    ) -> BlockRegistryBuilder:
-        """
-        Add multiple element classes to the registry configuration.
-
-        Args:
-            element_classes: List of element classes to add
-
-        Returns:
-            Self for method chaining
-        """
-        for element_class in element_classes:
-            self.add_element(element_class)
-        return self
-
-    def remove_element(
-        self, element_class: Type[NotionBlockElement]
-    ) -> BlockRegistryBuilder:
+    def remove_element(self, element_class: Type[NotionBlockElement]) -> Self:
         """
         Remove an element class from the registry configuration.
 
@@ -132,160 +82,97 @@ class BlockRegistryBuilder:
         self._elements.pop(element_class.__name__, None)
         return self
 
-    def move_element_to_end(
-        self, element_class: Type[NotionBlockElement]
-    ) -> BlockRegistryBuilder:
-        """
-        Move an existing element to the end of the registry.
-        If the element doesn't exist, it will be added.
+    # WITH methods (existing)
+    def with_paragraphs(self) -> Self:
+        """Add support for paragraph elements."""
+        return self._add_element(ParagraphElement)
 
-        Args:
-            element_class: The element class to move
+    def with_headings(self) -> Self:
+        """Add support for heading elements."""
+        return self._add_element(HeadingElement)
 
-        Returns:
-            Self for method chaining
-        """
-        return self.add_element(element_class)
+    def with_callouts(self) -> Self:
+        """Add support for callout elements."""
+        return self._add_element(CalloutElement)
 
-    def _ensure_paragraph_at_end(self) -> None:
-        """
-        Internal method to ensure ParagraphElement is the last element in the registry.
-        """
-        if ParagraphElement.__name__ in self._elements:
-            paragraph_class = self._elements.pop(ParagraphElement.__name__)
-            self._elements[ParagraphElement.__name__] = paragraph_class
+    def with_code(self) -> Self:
+        """Add support for code blocks."""
+        return self._add_element(CodeElement)
 
-    def with_paragraphs(self) -> BlockRegistryBuilder:
-        """
-        Add support for paragraph elements.
-        """
-        return self.add_element(ParagraphElement)
+    def with_dividers(self) -> Self:
+        """Add support for divider elements."""
+        return self._add_element(DividerElement)
 
-    def with_headings(self) -> BlockRegistryBuilder:
-        """
-        Add support for heading elements.
-        """
-        return self.add_element(HeadingElement)
+    def with_tables(self) -> Self:
+        """Add support for tables."""
+        return self._add_element(TableElement)
 
-    def with_callouts(self) -> BlockRegistryBuilder:
-        """
-        Add support for callout elements.
-        """
-        return self.add_element(CalloutElement)
+    def with_bulleted_list(self) -> Self:
+        """Add support for bulleted list elements (unordered lists)."""
+        return self._add_element(BulletedListElement)
 
-    def with_code(self) -> BlockRegistryBuilder:
-        """
-        Add support for code blocks.
-        """
-        return self.add_element(CodeBlockElement)
+    def with_numbered_list(self) -> Self:
+        """Add support for numbered list elements (ordered lists)."""
+        return self._add_element(NumberedListElement)
 
-    def with_dividers(self) -> BlockRegistryBuilder:
-        """
-        Add support for divider elements.
-        """
-        return self.add_element(DividerElement)
+    def with_toggles(self) -> Self:
+        """Add support for toggle elements."""
+        return self._add_element(ToggleElement)
 
-    def with_tables(self) -> BlockRegistryBuilder:
-        """
-        Add support for tables.
-        """
-        return self.add_element(TableElement)
+    def with_quotes(self) -> Self:
+        """Add support for quote elements."""
+        return self._add_element(QuoteElement)
 
-    def with_bulleted_list(self) -> BlockRegistryBuilder:
-        """
-        Add support for bulleted list elements (unordered lists).
-        """
-        return self.add_element(BulletedListElement)
+    def with_todos(self) -> Self:
+        """Add support for todo elements."""
+        return self._add_element(TodoElement)
 
-    def with_numbered_list(self) -> BlockRegistryBuilder:
-        """
-        Add support for numbered list elements (ordered lists).
-        """
-        return self.add_element(NumberedListElement)
+    def with_bookmarks(self) -> Self:
+        """Add support for bookmark elements."""
+        return self._add_element(BookmarkElement)
 
-    def with_toggles(self) -> BlockRegistryBuilder:
-        """
-        Add support for toggle elements.
-        """
-        return self.add_element(ToggleElement)
-
-    def with_quotes(self) -> BlockRegistryBuilder:
-        """
-        Add support for quote elements.
-        """
-        return self.add_element(QuoteElement)
-
-    def with_todos(self) -> BlockRegistryBuilder:
-        """
-        Add support for todo elements.
-        """
-        return self.add_element(TodoElement)
+    def with_images(self) -> Self:
+        """Add support for image elements."""
+        return self._add_element(ImageElement)
 
-    def with_bookmarks(self) -> BlockRegistryBuilder:
-        """
-        Add support for bookmark elements.
-        """
-        return self.add_element(BookmarkElement)
+    def with_videos(self) -> Self:
+        """Add support for video elements."""
+        return self._add_element(VideoElement)
 
-    def with_images(self) -> BlockRegistryBuilder:
-        """
-        Add support for image elements.
-        """
-        return self.add_element(ImageElement)
+    def with_embeds(self) -> Self:
+        """Add support for embed elements."""
+        return self._add_element(EmbedElement)
 
-    def with_videos(self) -> BlockRegistryBuilder:
-        """
-        Add support for video elements.
-        """
-        return self.add_element(VideoElement)
+    def with_audio(self) -> Self:
+        """Add support for audio elements."""
+        return self._add_element(AudioElement)
 
-    def with_embeds(self) -> BlockRegistryBuilder:
-        """
-        Add support for embed elements.
-        """
-        return self.add_element(EmbedElement)
+    def with_mention(self) -> Self:
+        """Add support for mention elements."""
+        return self._add_element(MentionElement)
 
-    def with_audio(self) -> BlockRegistryBuilder:
-        """
-        Add support for audio elements.
-        """
-        return self.add_element(AudioElement)
+    def with_toggleable_heading_element(self) -> Self:
+        """Add support for toggleable heading elements."""
+        return self._add_element(ToggleableHeadingElement)
 
-    def with_media_support(self) -> BlockRegistryBuilder:
-        """
-        Add support for media elements (images, videos, audio).
-        """
-        return self.with_images().with_videos().with_audio()
-
-    def with_mention(self) -> BlockRegistryBuilder:
-        return self.add_element(MentionElement)
-
-    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(ColumnElement)
+    def with_columns(self) -> Self:
+        """Add support for column elements."""
+        return self._add_element(ColumnElement)
 
     def build(self) -> BlockRegistry:
         """
         Build and return the configured BlockRegistry instance.
 
         This automatically ensures that ParagraphElement is at the end
-        of the registry (if present) as a fallback element, unless
-        this behavior was explicitly disabled.
+        of the registry as a fallback element.
 
         Returns:
             A configured BlockRegistry instance
         """
         from notionary.blocks import BlockRegistry
 
-        if ParagraphElement.__name__ not in self._elements:
-            self.add_element(ParagraphElement)
-        else:
-            self._ensure_paragraph_at_end()
+        # Ensure ParagraphElement is always present and at the end
+        self._ensure_paragraph_at_end()
 
         registry = BlockRegistry()
 
@@ -294,3 +181,28 @@ class BlockRegistryBuilder:
             registry.register(element_class)
 
         return registry
+
+    def _ensure_paragraph_at_end(self) -> None:
+        """
+        Internal method to ensure ParagraphElement is the last element in the registry.
+        If ParagraphElement is not present, it will be added.
+        """
+        # Remove if present, then always add at the end
+        self._elements.pop(ParagraphElement.__name__, None)
+        self._elements[ParagraphElement.__name__] = ParagraphElement
+
+    def _add_element(self, element_class: Type[NotionBlockElement]) -> Self:
+        """
+        Add an element class to the registry configuration.
+        If the element already exists, it's moved to the end.
+
+        Args:
+            element_class: The element class to add
+
+        Returns:
+            Self for method chaining
+        """
+        self._elements.pop(element_class.__name__, None)
+        self._elements[element_class.__name__] = element_class
+
+        return self