notionary 0.2.19__py3-none-any.whl → 0.2.22__py3-none-any.whl

notionary/blocks/pdf/pdf_element.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.file.file_element_models import ExternalFile, FileBlock, FileType
+from notionary.blocks.mixins.captions import CaptionMixin
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
+from notionary.blocks.models import Block, BlockCreateResult, BlockType
+from notionary.blocks.pdf.pdf_models import CreatePdfBlock
+
+
+class PdfElement(BaseBlockElement, CaptionMixin):
+    """
+    Handles conversion between Markdown PDF embeds and Notion PDF blocks.
+
+    Markdown PDF syntax:
+    - [pdf](https://example.com/document.pdf) - External URL
+    - [pdf](https://example.com/document.pdf)(caption:Annual Report 2024) - URL with caption
+    - (caption:User Manual)[pdf](https://example.com/manual.pdf) - caption before URL
+    - [pdf](notion://file_id_here)(caption:Notion hosted file) - Notion hosted file
+    - [pdf](upload://upload_id_here)(caption:File upload) - File upload
+
+    Supports all three PDF types: external, notion-hosted, and file uploads.
+    """
+
+    # Flexible pattern that can handle caption in any position
+    PDF_PATTERN = re.compile(r"\[pdf\]\(((?:https?://|notion://|upload://)[^\s\"]+)\)")
+
+    @classmethod
+    def match_notion(cls, block: Block) -> bool:
+        # Notion PDF block covers PDFs
+        return block.type == BlockType.PDF and block.pdf
+
+    @classmethod
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """Convert markdown PDF link to Notion FileBlock (used for PDF)."""
+        # Use our own regex to find the PDF URL
+        pdf_match = cls.PDF_PATTERN.search(text.strip())
+        if not pdf_match:
+            return None
+
+        url = pdf_match.group(1)
+
+        # Use mixin to extract caption (if present anywhere in text)
+        caption_text = cls.extract_caption(text.strip())
+        caption_rich_text = cls.build_caption_rich_text(caption_text or "")
+
+        # Build FileBlock using FileType enum (reused for PDF)
+        pdf_block = FileBlock(
+            type=FileType.EXTERNAL,
+            external=ExternalFile(url=url),
+            caption=caption_rich_text,
+        )
+
+        return CreatePdfBlock(pdf=pdf_block)
+
+    @classmethod
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        if block.type != BlockType.PDF or not block.pdf:
+            return None
+
+        pb: FileBlock = block.pdf
+
+        if pb.type == FileType.EXTERNAL and pb.external:
+            url = pb.external.url
+        elif pb.type == FileType.FILE and pb.file:
+            url = pb.file.url
+        elif pb.type == FileType.FILE_UPLOAD:
+            return None
+        else:
+            return None
+
+        result = f"[pdf]({url})"
+
+        # Add caption if present
+        caption_markdown = await cls.format_caption_for_markdown(pb.caption or [])
+        if caption_markdown:
+            result += caption_markdown
+
+        return result
+
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for PDF blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="PDF blocks embed and display PDF documents from external URLs with optional captions",
+            syntax_examples=[
+                "[pdf](https://example.com/document.pdf)",
+                "[pdf](https://example.com/report.pdf)(caption:Annual Report 2024)",
+                "(caption:User Manual)[pdf](https://example.com/manual.pdf)",
+                "[pdf](https://example.com/guide.pdf)(caption:**Important** documentation)",
+            ],
+            usage_guidelines="Use for embedding PDF documents that can be viewed inline. Supports external URLs and Notion-hosted files. Caption supports rich text formatting and should describe the PDF content.",
+        )

notionary/blocks/pdf/pdf_markdown_node.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from notionary.markdown.markdown_node import MarkdownNode
+from notionary.blocks.mixins.captions import CaptionMarkdownNodeMixin
+
+
+class PdfMarkdownNodeParams(BaseModel):
+    url: str
+    caption: Optional[str] = None
+
+
+class PdfMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    """
+    Programmatic interface for creating Notion-style Markdown PDF embeds.
+    """
+
+    def __init__(self, url: str, caption: Optional[str] = None):
+        self.url = url
+        self.caption = caption or ""
+
+    @classmethod
+    def from_params(cls, params: PdfMarkdownNodeParams) -> PdfMarkdownNode:
+        return cls(url=params.url, caption=params.caption)
+
+    def to_markdown(self) -> str:
+        """Return the Markdown representation.
+
+        Examples:
+        - [pdf](https://example.com/document.pdf)
+        - [pdf](https://example.com/document.pdf)(caption:Critical safety information)
+        """
+        base_markdown = f"[pdf]({self.url})"
+        return self.append_caption_to_markdown(base_markdown, self.caption)

notionary/blocks/pdf/pdf_models.py

@@ -0,0 +1,11 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+from notionary.blocks.file.file_element_models import FileBlock
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+
+
+class CreatePdfBlock(BaseModel):
+    type: Literal["pdf"] = "pdf"
+    pdf: FileBlock

notionary/blocks/quote/__init__.py

@@ -1,7 +1,16 @@
-from .quote_element import QuoteElement
-from .quote_markdown_node import QuoteMarkdownNode
+"""Quote block handling for Notionary."""
+
+from notionary.blocks.quote.quote_element import QuoteElement
+from notionary.blocks.quote.quote_markdown_node import (
+    QuoteMarkdownBlockParams,
+    QuoteMarkdownNode,
+)
+from notionary.blocks.quote.quote_models import CreateQuoteBlock, QuoteBlock
 
 __all__ = [
     "QuoteElement",
+    "QuoteBlock",
+    "CreateQuoteBlock",
     "QuoteMarkdownNode",
+    "QuoteMarkdownBlockParams",
 ]

notionary/blocks/quote/quote_element.py

@@ -1,34 +1,35 @@
+from __future__ import annotations
+
 import re
-from typing import Dict, Any, Optional, List, Tuple
+from typing import Optional
+
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
+from notionary.blocks.models import Block, BlockCreateResult, BlockType
+from notionary.blocks.quote.quote_models import CreateQuoteBlock, QuoteBlock
+from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.types import BlockColor
 
-from notionary.blocks import NotionBlockElement, NotionBlockResult
-from notionary.blocks import ElementPromptContent, ElementPromptBuilder
 
-class QuoteElement(NotionBlockElement):
+class QuoteElement(BaseBlockElement):
     """
     Handles conversion between Markdown quotes and Notion quote blocks.
+
     Markdown quote syntax:
-    - [quote](Simple quote text)
+    - > Simple quote text
+
+    Only single-line quotes without author metadata.
     """
 
-    # Einzeilig, kein Author, kein Anführungszeichen-Kram mehr!
-    PATTERN = re.compile(r'^\[quote\]\(([^\n\r]+)\)$')
+    PATTERN = re.compile(r"^>\s*(.+)$")
 
     @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())
+    def match_notion(cls, block: Block) -> bool:
+        return block.type == BlockType.QUOTE and block.quote
 
     @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
-
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """Convert markdown quote to Notion QuoteBlock."""
         match = cls.PATTERN.match(text.strip())
         if not match:
             return None
@@ -37,56 +38,38 @@ class QuoteElement(NotionBlockElement):
         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":
+        # Reject multiline quotes
+        if "\n" in content or "\r" in content:
             return None
 
-        rich_text = block.get("quote", {}).get("rich_text", [])
-        content = cls._extract_text_content(rich_text)
-        if not content.strip():
-            return None
+        rich_text = await TextInlineFormatter.parse_inline_formatting(content)
 
-        return f"[quote]({content.strip()})"
+        quote_content = QuoteBlock(rich_text=rich_text, color=BlockColor.DEFAULT)
+        return CreateQuoteBlock(quote=quote_content)
 
     @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
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        if block.type != BlockType.QUOTE or not block.quote:
+            return None
 
-    @classmethod
-    def is_multiline(cls) -> bool:
-        return False
+        rich = block.quote.rich_text
+        text = await TextInlineFormatter.extract_text_with_formatting(rich)
 
-    @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"
-        )
+        if not text.strip():
+            return None
+
+        return f"> {text.strip()}"
 
     @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()
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for quote blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Quote blocks display highlighted quotations or emphasized text",
+            syntax_examples=[
+                "> This is an important quote",
+                "> The only way to do great work is to love what you do",
+                "> Innovation distinguishes between a leader and a follower",
+            ],
+            usage_guidelines="Use for quotations, important statements, or text that should be visually emphasized. Content should be meaningful and stand out from regular paragraphs.",
         )

notionary/blocks/quote/quote_markdown_node.py

@@ -1,15 +1,18 @@
 from __future__ import annotations
 
 from pydantic import BaseModel
-from notionary.blocks.markdown_node import MarkdownNode
+
+from notionary.markdown.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)
+    Example: > This is a quote
     """
 
     def __init__(self, text: str):
@@ -20,4 +23,4 @@ class QuoteMarkdownNode(MarkdownNode):
         return cls(text=params.text)
 
     def to_markdown(self) -> str:
-        return f"[quote]({self.text})"
+        return f"> {self.text}"

notionary/blocks/quote/quote_models.py

@@ -0,0 +1,18 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from notionary.blocks.models import Block
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+from notionary.blocks.types import BlockColor
+
+
+class QuoteBlock(BaseModel):
+    rich_text: list[RichTextObject]
+    color: BlockColor = BlockColor.DEFAULT
+    children: list[Block] = Field(default_factory=list)
+
+
+class CreateQuoteBlock(BaseModel):
+    type: Literal["quote"] = "quote"
+    quote: QuoteBlock

notionary/blocks/registry/__init__.py

@@ -0,0 +1,4 @@
+from .block_registry import BlockRegistry
+from .block_registry_builder import BlockRegistryBuilder
+
+__all__ = ["BlockRegistryBuilder", "BlockRegistry"]

notionary/blocks/registry/block_registry.py

@@ -1,156 +1,95 @@
 from __future__ import annotations
-from typing import Dict, Any, Optional, List, Set, Type
 
-from notionary.blocks import NotionBlockElement
-from notionary.page.markdown_syntax_prompt_generator import (
-    MarkdownSyntaxPromptGenerator,
-)
-from notionary.blocks import TextInlineFormatter
+from typing import Optional, Type
 
-from notionary.blocks import NotionBlockElement
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.registry.block_registry_builder import BlockRegistryBuilder
 from notionary.telemetry import (
     ProductTelemetry,
-    NotionMarkdownSyntaxPromptEvent,
-    MarkdownToNotionConversionEvent,
-    NotionToMarkdownConversionEvent,
 )
 
 
 class BlockRegistry:
     """Registry of elements that can convert between Markdown and Notion."""
 
-    def __init__(self, elements=None):
+    def __init__(self, builder: Optional[BlockRegistryBuilder] = None):
         """
         Initialize a new registry instance.
 
         Args:
-            elements: Initial elements to register
+            builder: BlockRegistryBuilder instance to delegate operations to
         """
-        self._elements: List[NotionBlockElement] = []
-        self._element_types: Set[Type[NotionBlockElement]] = set()
-
-        if elements:
-            for element in elements:
-                self.register(element)
+        # Import here to avoid circular imports
+        from notionary.blocks.registry.block_registry_builder import (
+            BlockRegistryBuilder,
+        )
 
+        self._builder: BlockRegistryBuilder = builder or BlockRegistryBuilder()
         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:
+        from notionary.blocks.registry.block_registry_builder import (
+            BlockRegistryBuilder,
+        )
+
+        builder = BlockRegistryBuilder()
+        builder = (
+            builder.with_headings()
+            .with_callouts()
+            .with_code()
+            .with_dividers()
+            .with_tables()
+            .with_bulleted_list()
+            .with_numbered_list()
+            .with_toggles()
+            .with_toggleable_heading_element()
+            .with_quotes()
+            .with_todos()
+            .with_bookmarks()
+            .with_images()
+            .with_videos()
+            .with_embeds()
+            .with_audio()
+            .with_columns()
+            .with_equation()
+            .with_table_of_contents()
+            .with_breadcrumbs()
+            .with_child_database()
+            .with_paragraphs()  # position here is important - its a fallback!
+        )
+
+        return cls(builder=builder)
+
+    @property
+    def builder(self) -> BlockRegistryBuilder:
+        return self._builder
+
+    def register(self, element_class: Type[BaseBlockElement]) -> bool:
         """
-        Register an element class.
-
-        Args:
-            element_class: The element class to register
-
-        Returns:
-            bool: True if element was added, False if it already existed
+        Register an element class via builder.
         """
-        if element_class in self._element_types:
-            return False
+        initial_count = len(self._builder._elements)
+        self._builder._add_element(element_class)
+        return len(self._builder._elements) > initial_count
 
-        self._elements.append(element_class)
-        self._element_types.add(element_class)
-        return True
-
-    def deregister(self, element_class: Type[NotionBlockElement]) -> bool:
+    def deregister(self, element_class: Type[BaseBlockElement]) -> bool:
         """
-        Deregister an element class.
+        Deregister an element class via builder.
         """
-        if element_class in self._element_types:
-            self._elements.remove(element_class)
-            self._element_types.remove(element_class)
-            return True
-        return False
+        initial_count = len(self._builder._elements)
+        self._builder.remove_element(element_class)
+        return len(self._builder._elements) < initial_count
 
-    def contains(self, element_class: Type[NotionBlockElement]) -> bool:
+    def contains(self, element_class: Type[BaseBlockElement]) -> bool:
         """
         Checks if a specific element is contained in the registry.
-
-        Args:
-            element_class: The element class to check.
-
-        Returns:
-            bool: True if the element is contained, otherwise False.
         """
-        return element_class in self._elements
-
-    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
+        return element_class.__name__ in self._builder._elements
 
-    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:
-            self.telemetry.capture(
-                MarkdownToNotionConversionEvent(
-                    handler_element_name=handler.__name__,
-                )
-            )
-
-            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:
-            self.telemetry.capture(
-                NotionToMarkdownConversionEvent(
-                    handler_element_name=handler.__name__,
-                )
-            )
-
-            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]]:
+    def get_elements(self) -> list[Type[BaseBlockElement]]:
         """Get all registered elements."""
-        return self._elements.copy()
-
-    def get_notion_markdown_syntax_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 = element_classes + [TextInlineFormatter]
-
-        self.telemetry.capture(NotionMarkdownSyntaxPromptEvent())
-
-        return MarkdownSyntaxPromptGenerator.generate_system_prompt(element_classes)
-
-    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
+        return list(self._builder._elements.values())