notionary 0.2.27__py3-none-any.whl → 0.2.28__py3-none-any.whl

notionary/blocks/paragraph/paragraph_markdown_node.py

@@ -1,16 +0,0 @@
-from __future__ import annotations
-
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-
-
-class ParagraphMarkdownNode(MarkdownNode):
-    """
-    Enhanced Paragraph node with Pydantic integration.
-    Programmatic interface for creating Markdown paragraphs.
-    Paragraphs are standard text without special block formatting.
-    """
-
-    text: str
-
-    def to_markdown(self) -> str:
-        return self.text

notionary/blocks/paragraph/paragraph_models.py

@@ -1,16 +0,0 @@
-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

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

notionary/blocks/pdf/pdf_element.py

@@ -1,146 +0,0 @@
-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,
-    FileUploadFile,
-)
-from notionary.blocks.mixins.captions import CaptionMixin
-from notionary.blocks.mixins.file_upload.file_upload_mixin import FileUploadMixin
-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, FileUploadMixin):
-    r"""
-    Handles conversion between Markdown PDF embeds and Notion PDF blocks.
-
-    Supports both external URLs and local PDF file uploads.
-
-    Markdown PDF syntax:
-    - [pdf](https://example.com/document.pdf) - External URL
-    - [pdf](./local/document.pdf) - Local PDF file (will be uploaded)
-    - [pdf](C:\Documents\report.pdf) - Absolute local path (will be uploaded)
-    - [pdf](https://example.com/document.pdf)(caption:Annual Report 2024) - With caption
-    - [pdf](notion://file_id_here)(caption:Notion hosted file) - Notion hosted file
-    - [pdf](upload://upload_id_here)(caption:File upload) - File upload
-    """
-
-    PDF_PATTERN = re.compile(r"\[pdf\]\(([^)]+)\)")
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        """Match Notion PDF blocks."""
-        return block.type == BlockType.PDF and block.pdf
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> Optional[BlockCreateResult]:
-        """Convert markdown PDF link to Notion PDF block."""
-        pdf_path = cls._extract_pdf_path(text.strip())
-
-        if not pdf_path:
-            return None
-
-        cls.logger.info(f"Processing PDF: {pdf_path}")
-
-        # Extract caption
-        caption_text = cls.extract_caption(text.strip())
-        caption_rich_text = cls.build_caption_rich_text(caption_text or "")
-
-        # Handle different types of PDF sources
-        if pdf_path.startswith(("notion://", "upload://")):
-            # Handle special Notion schemes (existing functionality)
-            cls.logger.info(f"Using special scheme: {pdf_path}")
-            pdf_block = FileBlock(
-                type=FileType.EXTERNAL,
-                external=ExternalFile(url=pdf_path),
-                caption=caption_rich_text,
-            )
-
-        elif cls._is_local_file_path(pdf_path):
-            # Handle local PDF file upload using mixin
-            cls.logger.debug(f"Detected local PDF file: {pdf_path}")
-
-            # Upload the local PDF file with PDF category validation
-            file_upload_id = await cls._upload_local_file(pdf_path, "pdf")
-            if not file_upload_id:
-                cls.logger.error(f"Failed to upload PDF: {pdf_path}")
-                return None
-
-            # Create FILE_UPLOAD block
-            pdf_block = FileBlock(
-                type=FileType.FILE_UPLOAD,
-                file_upload=FileUploadFile(id=file_upload_id),
-                caption=caption_rich_text,
-            )
-
-        else:
-            # Handle external URL
-            cls.logger.debug(f"Using external PDF URL: {pdf_path}")
-
-            pdf_block = FileBlock(
-                type=FileType.EXTERNAL,
-                external=ExternalFile(url=pdf_path),
-                caption=caption_rich_text,
-            )
-
-        return CreatePdfBlock(pdf=pdf_block)
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        """Convert Notion PDF block to markdown."""
-        if block.type != BlockType.PDF or not block.pdf:
-            return None
-
-        pb: FileBlock = block.pdf
-
-        # Determine the source for markdown
-        if pb.type == FileType.EXTERNAL and pb.external:
-            source = pb.external.url
-        elif pb.type == FileType.FILE and pb.file:
-            source = pb.file.url
-        else:
-            return None
-
-        result = f"[pdf]({source})"
-
-        # 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 or upload local PDF files with optional captions",
-            syntax_examples=[
-                "[pdf](https://example.com/document.pdf)",
-                "[pdf](./local/report.pdf)",
-                "[pdf](C:\\Documents\\manual.pdf)",
-                "[pdf](https://example.com/report.pdf)(caption:Annual Report 2024)",
-                "(caption:User Manual)[pdf](./manual.pdf)",
-                "[pdf](./guide.pdf)(caption:**Important** documentation)",
-            ],
-            usage_guidelines="Use for embedding PDF documents that can be viewed inline. Supports both external URLs and local PDF file uploads. Local PDF files will be automatically uploaded to Notion. Caption supports rich text formatting and should describe the PDF content.",
-        )
-
-    @classmethod
-    def _extract_pdf_path(cls, text: str) -> Optional[str]:
-        """Extract PDF path/URL from text, handling caption patterns."""
-        clean_text = cls.remove_caption(text)
-
-        match = cls.PDF_PATTERN.search(clean_text)
-        if match:
-            return match.group(1).strip()
-
-        return None

notionary/blocks/pdf/pdf_markdown_node.py

@@ -1,24 +0,0 @@
-from typing import Optional
-
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-from notionary.blocks.mixins.captions import CaptionMarkdownNodeMixin
-
-
-class PdfMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
-    """
-    Enhanced PDF node with Pydantic integration.
-    Programmatic interface for creating Notion-style PDF blocks.
-    """
-
-    url: str
-    caption: Optional[str] = None
-
-    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

@@ -1,11 +0,0 @@
-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,14 +0,0 @@
-"""Quote block handling for Notionary."""
-
-from notionary.blocks.quote.quote_element import QuoteElement
-from notionary.blocks.quote.quote_markdown_node import (
-    QuoteMarkdownNode,
-)
-from notionary.blocks.quote.quote_models import CreateQuoteBlock, QuoteBlock
-
-__all__ = [
-    "QuoteElement",
-    "QuoteBlock",
-    "CreateQuoteBlock",
-    "QuoteMarkdownNode",
-]

notionary/blocks/quote/quote_element.py

@@ -1,75 +0,0 @@
-from __future__ import annotations
-
-import re
-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
-
-
-class QuoteElement(BaseBlockElement):
-    """
-    Handles conversion between Markdown quotes and Notion quote blocks.
-
-    Markdown quote syntax:
-    - > Simple quote text
-
-    Only single-line quotes without author metadata.
-    """
-
-    PATTERN = re.compile(r"^>\s*(.+)$")
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        return block.type == BlockType.QUOTE and block.quote
-
-    @classmethod
-    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
-
-        content = match.group(1).strip()
-        if not content:
-            return None
-
-        # Reject multiline quotes
-        if "\n" in content or "\r" in content:
-            return None
-
-        rich_text = await TextInlineFormatter.parse_inline_formatting(content)
-
-        quote_content = QuoteBlock(rich_text=rich_text, color=BlockColor.DEFAULT)
-        return CreateQuoteBlock(quote=quote_content)
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        if block.type != BlockType.QUOTE or not block.quote:
-            return None
-
-        rich = block.quote.rich_text
-        text = await TextInlineFormatter.extract_text_with_formatting(rich)
-
-        if not text.strip():
-            return None
-
-        return f"> {text.strip()}"
-
-    @classmethod
-    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,16 +0,0 @@
-from __future__ import annotations
-
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-
-
-class QuoteMarkdownNode(MarkdownNode):
-    """
-    Enhanced Quote node with Pydantic integration.
-    Programmatic interface for creating Notion-style quote blocks.
-    Example: > This is a quote
-    """
-
-    text: str
-
-    def to_markdown(self) -> str:
-        return f"> {self.text}"

notionary/blocks/quote/quote_models.py

@@ -1,18 +0,0 @@
-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

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

notionary/blocks/registry/block_registry.py

@@ -1,150 +0,0 @@
-from __future__ import annotations
-
-from collections import OrderedDict
-from typing import Type, Set
-
-from notionary.blocks.base_block_element import BaseBlockElement
-from notionary.telemetry import ProductTelemetry
-
-from notionary.blocks.audio import AudioElement
-from notionary.blocks.bookmark import BookmarkElement
-from notionary.blocks.breadcrumbs import BreadcrumbElement
-from notionary.blocks.bulleted_list import BulletedListElement
-from notionary.blocks.callout import CalloutElement
-from notionary.blocks.child_database import ChildDatabaseElement
-from notionary.blocks.code import CodeElement
-from notionary.blocks.column import ColumnElement, ColumnListElement
-from notionary.blocks.divider import DividerElement
-from notionary.blocks.embed import EmbedElement
-from notionary.blocks.equation import EquationElement
-from notionary.blocks.file import FileElement
-from notionary.blocks.heading import HeadingElement
-from notionary.blocks.image_block import ImageElement
-from notionary.blocks.numbered_list import NumberedListElement
-from notionary.blocks.paragraph import ParagraphElement
-from notionary.blocks.pdf import PdfElement
-from notionary.blocks.quote import QuoteElement
-from notionary.blocks.table import TableElement
-from notionary.blocks.table_of_contents import TableOfContentsElement
-from notionary.blocks.todo import TodoElement
-from notionary.blocks.toggle import ToggleElement
-from notionary.blocks.toggleable_heading import ToggleableHeadingElement
-from notionary.blocks.video import VideoElement
-
-
-class BlockRegistry:
-    """Registry of elements that can convert between Markdown and Notion."""
-
-    _DEFAULT_ELEMENTS = [
-        HeadingElement,
-        CalloutElement,
-        CodeElement,
-        DividerElement,
-        TableElement,
-        BulletedListElement,
-        NumberedListElement,
-        ToggleElement,
-        ToggleableHeadingElement,
-        QuoteElement,
-        TodoElement,
-        BookmarkElement,
-        ImageElement,
-        VideoElement,
-        EmbedElement,
-        AudioElement,
-        ColumnListElement,
-        ColumnElement,
-        EquationElement,
-        TableOfContentsElement,
-        BreadcrumbElement,
-        ChildDatabaseElement,
-        FileElement,
-        PdfElement,
-        ParagraphElement,  # Must be last as fallback!
-    ]
-
-    def __init__(self, excluded_elements: Set[Type[BaseBlockElement]] = None):
-        """
-        Initialize a new registry instance.
-
-        Args:
-            excluded_elements: Set of element classes to exclude from the registry
-        """
-        self._elements = OrderedDict()
-        self._excluded_elements = excluded_elements or set()
-        self.telemetry = ProductTelemetry()
-
-        # Initialize with default elements minus excluded ones
-        self._initialize_default_elements()
-
-    @classmethod
-    def create_registry(
-        cls, excluded_elements: Set[Type[BaseBlockElement]] = None
-    ) -> "BlockRegistry":
-        """
-        Create a registry with all standard elements in recommended order.
-
-        Args:
-            excluded_elements: Set of element classes to exclude from the registry
-        """
-        return cls(excluded_elements=excluded_elements)
-
-    def _initialize_default_elements(self) -> None:
-        """Initialize registry with default elements minus excluded ones."""
-        for element_class in self._DEFAULT_ELEMENTS:
-            if element_class not in self._excluded_elements:
-                self._elements[element_class.__name__] = element_class
-
-    def exclude_elements(
-        self, *element_classes: Type[BaseBlockElement]
-    ) -> BlockRegistry:
-        """
-        Create a new registry with additional excluded elements.
-
-        Args:
-            element_classes: Element classes to exclude
-
-        Returns:
-            New BlockRegistry instance with excluded elements
-        """
-        new_excluded = self._excluded_elements.copy()
-        new_excluded.update(element_classes)
-        return BlockRegistry(excluded_elements=new_excluded)
-
-    def register(self, element_class: Type[BaseBlockElement]) -> bool:
-        """
-        Register an element class.
-
-        Args:
-            element_class: The element class to register
-
-        Returns:
-            True if element was added, False if it already existed
-        """
-        if element_class.__name__ in self._elements:
-            return False
-
-        self._elements[element_class.__name__] = element_class
-        return True
-
-    def remove(self, element_class: Type[BaseBlockElement]) -> bool:
-        """
-        Remove an element class.
-        """
-        return self._elements.pop(element_class.__name__, None) is not None
-
-    def contains(self, element_class: Type[BaseBlockElement]) -> bool:
-        """
-        Checks if a specific element is contained in the registry.
-        """
-        return element_class.__name__ in self._elements
-
-    def get_elements(self) -> list[Type[BaseBlockElement]]:
-        """Get all registered elements in order."""
-        return list(self._elements.values())
-
-    def is_excluded(self, element_class: Type[BaseBlockElement]) -> bool:
-        """
-        Check if an element class is excluded.
-        """
-        return element_class in self._excluded_elements

notionary/blocks/rich_text/__init__.py

@@ -1,33 +0,0 @@
-"""Rich text handling for Notionary."""
-
-from notionary.blocks.rich_text.rich_text_models import (
-    EquationObject,
-    LinkObject,
-    MentionDatabaseRef,
-    MentionDate,
-    MentionLinkPreview,
-    MentionObject,
-    MentionPageRef,
-    MentionTemplateMention,
-    MentionUserRef,
-    RichTextObject,
-    TextAnnotations,
-    TextContent,
-)
-from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
-
-__all__ = [
-    "RichTextObject",
-    "TextAnnotations",
-    "LinkObject",
-    "TextContent",
-    "EquationObject",
-    "MentionUserRef",
-    "MentionPageRef",
-    "MentionDatabaseRef",
-    "MentionLinkPreview",
-    "MentionDate",
-    "MentionTemplateMention",
-    "MentionObject",
-    "TextInlineFormatter",
-]