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

notionary/blocks/paragraph/__init__.py

@@ -1,7 +1,17 @@
-from .paragraph_element import ParagraphElement
-from .paragraph_markdown_node import ParagraphMarkdownNode
+from notionary.blocks.paragraph.paragraph_element import ParagraphElement
+from notionary.blocks.paragraph.paragraph_markdown_node import (
+    ParagraphMarkdownBlockParams,
+    ParagraphMarkdownNode,
+)
+from notionary.blocks.paragraph.paragraph_models import (
+    CreateParagraphBlock,
+    ParagraphBlock,
+)
 
 __all__ = [
     "ParagraphElement",
+    "ParagraphBlock",
+    "CreateParagraphBlock",
     "ParagraphMarkdownNode",
+    "ParagraphMarkdownBlockParams",
 ]

notionary/blocks/paragraph/paragraph_element.py

@@ -1,84 +1,42 @@
-from typing import Dict, Any, Optional
+from __future__ import annotations
 
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import (
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
-)
-from notionary.blocks.shared.text_inline_formatter import TextInlineFormatter
+from typing import Optional
 
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.models import Block, BlockCreateResult
+from notionary.blocks.paragraph.paragraph_models import (
+    CreateParagraphBlock,
+    ParagraphBlock,
+)
+from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.types import BlockColor, BlockType
 
-class ParagraphElement(NotionBlockElement):
-    """Handles conversion between Markdown paragraphs and Notion paragraph blocks."""
 
-    @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """
-        Check if text is a markdown paragraph.
-        Paragraphs are essentially any text that isn't matched by other block elements.
-        Since paragraphs are the fallback element, this always returns True.
-        """
-        return True
+class ParagraphElement(BaseBlockElement):
+    """
+    Handles conversion between Markdown paragraphs and Notion paragraph blocks.
+    """
 
     @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
-        """Check if block is a Notion paragraph."""
-        return block.get("type") == "paragraph"
+    def match_notion(cls, block: Block) -> bool:
+        return block.type == "paragraph" and block.paragraph
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown paragraph to Notion paragraph block."""
+    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """Convert markdown text to a Notion ParagraphBlock."""
         if not text.strip():
             return None
 
-        return {
-            "type": "paragraph",
-            "paragraph": {
-                "rich_text": TextInlineFormatter.parse_inline_formatting(text)
-            },
-        }
+        rich = TextInlineFormatter.parse_inline_formatting(text)
 
-    @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion paragraph block to markdown paragraph."""
-        if block.get("type") != "paragraph":
-            return None
-
-        paragraph_data = block.get("paragraph", {})
-        rich_text = paragraph_data.get("rich_text", [])
-
-        text = TextInlineFormatter.extract_text_with_formatting(rich_text)
-        return text if text else None
+        paragraph_content = ParagraphBlock(rich_text=rich, color=BlockColor.DEFAULT)
+        return CreateParagraphBlock(paragraph=paragraph_content)
 
     @classmethod
-    def is_multiline(cls) -> bool:
-        return False
+    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        if block.type != "paragraph" or not block.paragraph:
+            return None
 
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the paragraph element,
-        including information about supported inline formatting.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Creates standard paragraph blocks for regular text content with support for inline formatting: "
-                "**bold**, *italic*, `code`, ~~strikethrough~~, __underline__, and [links](url)."
-            )
-            .with_usage_guidelines(
-                "Use for normal text content. Paragraphs are the default block type when no specific formatting is applied. "
-                "Apply inline formatting to highlight key points or provide links to resources."
-            )
-            .with_syntax("Just write text normally without any special prefix")
-            .with_examples(
-                [
-                    "This is a simple paragraph with plain text.",
-                    "This paragraph has **bold** and *italic* formatting.",
-                    "You can include [links](https://example.com) or `inline code`.",
-                    "Advanced formatting: ~~strikethrough~~ and __underlined text__.",
-                ]
-            )
-            .build()
-        )
+        rich_list = block.paragraph.rich_text
+        markdown = TextInlineFormatter.extract_text_with_formatting(rich_list)
+        return markdown or None

notionary/blocks/paragraph/paragraph_markdown_node.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 from pydantic import BaseModel
-from notionary.blocks.markdown_node import MarkdownNode
+
+from notionary.markdown.markdown_node import MarkdownNode
 
 
 class ParagraphMarkdownBlockParams(BaseModel):

notionary/blocks/paragraph/paragraph_models.py

@@ -0,0 +1,16 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+from notionary.blocks.types import BlockColor
+
+
+class ParagraphBlock(BaseModel):
+    rich_text: list[RichTextObject]
+    color: BlockColor = BlockColor.DEFAULT.value
+
+
+class CreateParagraphBlock(BaseModel):
+    type: Literal["paragraph"] = "paragraph"
+    paragraph: ParagraphBlock

notionary/blocks/pdf/__init__.py

@@ -0,0 +1,13 @@
+from notionary.blocks.pdf.pdf_element import PdfElement
+from notionary.blocks.pdf.pdf_markdown_node import (
+    PdfMarkdownNode,
+    PdfMarkdownNodeParams,
+)
+from notionary.blocks.pdf.pdf_models import CreatePdfBlock
+
+__all__ = [
+    "PdfElement",
+    "CreatePdfBlock",
+    "PdfMarkdownNode",
+    "PdfMarkdownNodeParams",
+]

notionary/blocks/pdf/pdf_element.py

@@ -0,0 +1,91 @@
+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.models import Block, BlockCreateResult, BlockType
+from notionary.blocks.paragraph.paragraph_models import (
+    CreateParagraphBlock,
+    ParagraphBlock,
+)
+from notionary.blocks.pdf.pdf_models import CreatePdfBlock
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+
+
+class PdfElement(BaseBlockElement):
+    """
+    Handles conversion between Markdown PDF embeds and Notion PDF blocks.
+
+    Markdown PDF syntax:
+    - [pdf](https://example.com/document.pdf "Caption")     # External URL
+    - [pdf](notion://file_id_here "Caption")                # Notion hosted file
+    - [pdf](upload://upload_id_here "Caption")              # File upload
+    - [pdf](https://example.com/document.pdf)               # Without caption
+
+    Supports all three PDF types: external, notion-hosted, and file uploads.
+    """
+
+    PATTERN = re.compile(
+        r"^\[pdf\]\("  # prefix
+        r'((?:https?://|notion://|upload://)[^\s\)"]+)'  # URL with protocol
+        r'(?:\s+"([^"]*)")?'  # optional caption
+        r"\)$"
+    )
+
+    @classmethod
+    def match_notion(cls, block: Block) -> bool:
+        # Notion PDF block covers PDFs
+        return block.type == BlockType.PDF and block.pdf
+
+    @classmethod
+    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """Convert markdown PDF link to Notion FileBlock (used for PDF) followed by an empty paragraph."""
+        match = cls.PATTERN.match(text.strip())
+        if not match:
+            return None
+
+        url, caption_text = match.group(1), match.group(2) or ""
+
+        # Build FileBlock using FileType enum (reused for PDF)
+        pdf_block = FileBlock(
+            type=FileType.EXTERNAL, external=ExternalFile(url=url), caption=[]
+        )
+        if caption_text.strip():
+            rt = RichTextObject.from_plain_text(caption_text)
+            pdf_block.caption = [rt]
+
+        empty_para = ParagraphBlock(rich_text=[])
+
+        return [
+            CreatePdfBlock(pdf=pdf_block),
+            CreateParagraphBlock(paragraph=empty_para),
+        ]
+
+    @classmethod
+    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        if block.type != BlockType.PDF or not block.pdf:
+            return None
+
+        pb: FileBlock = block.pdf
+
+        # Determine URL (only external and file types are valid for Markdown)
+        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:
+            # Uploaded PDF has no stable URL for Markdown
+            return None
+        else:
+            return None
+
+        if not pb.caption:
+            return f"[pdf]({url})"
+
+        caption_md = TextInlineFormatter.extract_text_with_formatting(pb.caption)
+        if caption_md:
+            return f'[pdf]({url} "{caption_md}")'
+        return f"[pdf]({url})"

notionary/blocks/pdf/pdf_markdown_node.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from notionary.markdown.markdown_node import MarkdownNode
+
+
+class PdfMarkdownNodeParams(BaseModel):
+    url: str
+    caption: Optional[str] = None
+
+
+class PdfMarkdownNode(MarkdownNode):
+    """
+    Programmatic interface for creating Notion-style Markdown PDF embeds.
+    Example: [pdf](https://example.com/document.pdf "My Caption")
+    """
+
+    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:
+        """
+        Convert to markdown as [pdf](url "caption") or [pdf](url) if caption is empty.
+        """
+        if self.caption:
+            return f'[pdf]({self.url} "{self.caption}")'
+        return f"[pdf]({self.url})"

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,34 @@
+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.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)
+
+    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"^\[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())
+    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
-
+    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 +37,22 @@ 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":
-            return None
-
-        rich_text = block.get("quote", {}).get("rich_text", [])
-        content = cls._extract_text_content(rich_text)
-        if not content.strip():
-            return None
+        # Parse inline formatting into rich text objects
+        rich_text = TextInlineFormatter.parse_inline_formatting(content)
 
-        return f"[quote]({content.strip()})"
+        # Return a typed QuoteBlock
+        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
+    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 = 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
 
-    @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()
-        )
+        return f"[quote]({text.strip()})"

notionary/blocks/quote/quote_markdown_node.py

@@ -1,11 +1,14 @@
 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.

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"]