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

notionary/blocks/embed/embed_element.py

@@ -1,98 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import Optional
-
-from notionary.blocks.base_block_element import BaseBlockElement
-from notionary.blocks.embed.embed_models import CreateEmbedBlock, EmbedBlock
-from notionary.blocks.file.file_element_models import (
-    ExternalFile,
-    FileUploadFile,
-    NotionHostedFile,
-)
-from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
-from notionary.blocks.models import Block, BlockCreateResult, BlockType
-from notionary.blocks.rich_text.rich_text_models import RichTextObject
-from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
-
-
-class EmbedElement(BaseBlockElement):
-    """
-    Handles conversion between Markdown embeds and Notion embed blocks.
-
-    Markdown embed syntax:
-    - [embed](https://example.com) - URL only
-    - [embed](https://example.com "Caption") - URL + caption
-    """
-
-    PATTERN = re.compile(
-        r"^\[embed\]\("  # prefix
-        r"(https?://[^\s\"]+)"  # URL
-        r"(?:\s+\"([^\"]+)\")?"  # optional caption
-        r"\)$"
-    )
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        return block.type == BlockType.EMBED and block.embed
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
-        """Convert markdown embed syntax to Notion EmbedBlock."""
-        match = cls.PATTERN.match(text.strip())
-        if not match:
-            return None
-
-        url, rich_text = match.group(1), match.group(2) or ""
-
-        # Build EmbedBlock
-        embed_block = EmbedBlock(url=url, caption=[])
-        if rich_text.strip():
-            rich_text_obj = RichTextObject.from_plain_text(rich_text.strip())
-            embed_block.caption = [rich_text_obj]
-
-        return CreateEmbedBlock(embed=embed_block)
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        if block.type != BlockType.EMBED or not block.embed:
-            return None
-
-        fo = block.embed
-
-        if isinstance(fo, (ExternalFile, NotionHostedFile)):
-            url = fo.url
-        elif isinstance(fo, FileUploadFile):
-            return None
-        else:
-            return None
-
-        if not fo.caption:
-            return f"[embed]({url})"
-
-        text_parts = []
-        for rt in fo.caption:
-            if rt.plain_text:
-                text_parts.append(rt.plain_text)
-            else:
-                formatted_text = await TextInlineFormatter.extract_text_with_formatting(
-                    [rt]
-                )
-                text_parts.append(formatted_text)
-        text = "".join(text_parts)
-
-        return f'[embed]({url} "{text}")'
-
-    @classmethod
-    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """Get system prompt information for embed blocks."""
-        return BlockElementMarkdownInformation(
-            block_type=cls.__name__,
-            description="Embed blocks display interactive content from external URLs like videos, maps, or widgets",
-            syntax_examples=[
-                "[embed](https://youtube.com/watch?v=123)",
-                '[embed](https://maps.google.com/location "Map Location")',
-                '[embed](https://codepen.io/pen/123 "Interactive Demo")',
-            ],
-            usage_guidelines="Use for embedding interactive content that supports iframe embedding. URL must be from a supported platform. Caption describes the embedded content.",
-        )

notionary/blocks/embed/embed_markdown_node.py

@@ -1,19 +0,0 @@
-from typing import Optional
-
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-
-
-class EmbedMarkdownNode(MarkdownNode):
-    """
-    Enhanced Embed node with Pydantic integration.
-    Programmatic interface for creating Notion-style Markdown embed blocks.
-    Example: [embed](https://example.com "Optional caption")
-    """
-
-    url: str
-    caption: Optional[str] = None
-
-    def to_markdown(self) -> str:
-        if self.caption:
-            return f'[embed]({self.url} "{self.caption}")'
-        return f"[embed]({self.url})"

notionary/blocks/embed/embed_models.py

@@ -1,14 +0,0 @@
-from pydantic import BaseModel, Field
-from typing_extensions import Literal
-
-from notionary.blocks.rich_text.rich_text_models import RichTextObject
-
-
-class EmbedBlock(BaseModel):
-    url: str
-    caption: list[RichTextObject] = Field(default_factory=list)
-
-
-class CreateEmbedBlock(BaseModel):
-    type: Literal["embed"] = "embed"
-    embed: EmbedBlock

notionary/blocks/equation/__init__.py

@@ -1,13 +0,0 @@
-from notionary.blocks.equation.equation_element import EquationElement
-from notionary.blocks.equation.equation_element_markdown_node import (
-    EquationMarkdownNode,
-)
-from notionary.blocks.equation.equation_models import CreateEquationBlock, EquationBlock
-
-__all__ = [
-    "EquationElement",
-    "EquationBlock",
-    "CreateEquationBlock",
-    "EquationMarkdownNode",
-    "EquationMarkdownBlockParams",
-]

notionary/blocks/equation/equation_element.py

@@ -1,133 +0,0 @@
-from __future__ import annotations
-
-import re
-import textwrap
-from typing import Optional
-
-from notionary.blocks.base_block_element import BaseBlockElement
-from notionary.blocks.equation.equation_models import CreateEquationBlock, EquationBlock
-from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
-from notionary.blocks.models import Block, BlockCreateResult
-from notionary.blocks.types import BlockType
-
-
-class EquationElement(BaseBlockElement):
-    """
-    Supports standard Markdown equation syntax:
-
-      - $$E = mc^2$$                           # simple equations
-      - $$E = mc^2 + \\frac{a}{b}$$           # complex equations with LaTeX
-
-    Uses $$...$$ parsing for block equations.
-    """
-
-    _EQUATION_PATTERN = re.compile(
-        r"^\$\$\s*(?P<expression>.*?)\s*\$\$$",
-        re.DOTALL,
-    )
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        return block.type == BlockType.EQUATION and block.equation
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
-        input_text = text.strip()
-
-        equation_match = cls._EQUATION_PATTERN.match(input_text)
-        if not equation_match:
-            return None
-
-        expression = equation_match.group("expression").strip()
-        if not expression:
-            return None
-
-        return CreateEquationBlock(equation=EquationBlock(expression=expression))
-
-    @classmethod
-    def create_from_markdown_block(
-        cls, opening_line: str, equation_lines: list[str]
-    ) -> BlockCreateResult:
-        """
-        Create a complete equation block from markdown components.
-        Handles multiline equations like:
-        $$
-        some
-        inline formula here
-        $$
-
-        Automatically handles:
-        - Indentation removal from multiline strings
-        - Single backslash conversion to double backslash for LaTeX line breaks
-        """
-        # Check if opening line is just $$
-        if opening_line.strip() != "$$":
-            return None
-
-        # Process equation lines if any exist
-        if equation_lines:
-            # Remove common indentation from all lines
-            raw_content = "\n".join(equation_lines)
-            dedented_content = textwrap.dedent(raw_content)
-
-            # Fix single backslashes at line ends for LaTeX line breaks
-            fixed_lines = cls._fix_latex_line_breaks(dedented_content.splitlines())
-            expression = "\n".join(fixed_lines).strip()
-
-            if expression:
-                return CreateEquationBlock(
-                    equation=EquationBlock(expression=expression)
-                )
-
-        return None
-
-    @classmethod
-    def _fix_latex_line_breaks(cls, lines: list[str]) -> list[str]:
-        """
-        Fix lines that end with single backslashes by converting them to double backslashes.
-        This makes LaTeX line breaks work correctly when users write single backslashes.
-
-        Examples:
-        - "a = b + c \" -> "a = b + c \\"
-        - "a = b + c \\\\" -> "a = b + c \\\\" (unchanged)
-        """
-        fixed_lines = []
-
-        for line in lines:
-            # Check if line ends with backslashes
-            backslash_match = re.search(r"(\\+)$", line)
-            if backslash_match:
-                backslashes = backslash_match.group(1)
-                # If odd number of backslashes, the last one needs to be doubled
-                if len(backslashes) % 2 == 1:
-                    line = line + "\\"
-
-            fixed_lines.append(line)
-
-        return fixed_lines
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        if block.type != BlockType.EQUATION or not block.equation:
-            return None
-
-        expression = (block.equation.expression or "").strip()
-        if not expression:
-            return None
-
-        return f"$${expression}$$"
-
-    @classmethod
-    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """Get system prompt information for equation blocks."""
-        return BlockElementMarkdownInformation(
-            block_type=cls.__name__,
-            description="Mathematical equations using standard Markdown LaTeX syntax",
-            syntax_examples=[
-                "$$E = mc^2$$",
-                "$$\\frac{a}{b} + \\sqrt{c}$$",
-                "$$\\int_0^\\infty e^{-x} dx = 1$$",
-                "$$\\sum_{i=1}^n i = \\frac{n(n+1)}{2}$$",
-            ],
-            usage_guidelines="Use for mathematical expressions and formulas. Supports LaTeX syntax. Wrap equations in double dollar signs ($$).",
-        )

notionary/blocks/equation/equation_element_markdown_node.py

@@ -1,23 +0,0 @@
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-
-
-class EquationMarkdownNode(MarkdownNode):
-    """
-    Enhanced Equation node with Pydantic integration.
-    Programmatic interface for creating Markdown equation blocks.
-    Uses standard Markdown equation syntax with double dollar signs.
-
-    Examples:
-    $$E = mc^2$$
-    $$\\frac{a}{b} + \\sqrt{c}$$
-    $$\\int_0^\\infty e^{-x} dx = 1$$
-    """
-
-    expression: str
-
-    def to_markdown(self) -> str:
-        expr = self.expression.strip()
-        if not expr:
-            return "$$$$"
-
-        return f"$${expr}$$"

notionary/blocks/equation/equation_models.py

@@ -1,11 +0,0 @@
-from pydantic import BaseModel
-from typing_extensions import Literal
-
-
-class EquationBlock(BaseModel):
-    expression: str
-
-
-class CreateEquationBlock(BaseModel):
-    type: Literal["equation"] = "equation"
-    equation: EquationBlock

notionary/blocks/file/__init__.py

@@ -1,23 +0,0 @@
-from notionary.blocks.file.file_element import FileElement
-from notionary.blocks.file.file_element_markdown_node import (
-    FileMarkdownNode,
-)
-from notionary.blocks.file.file_element_models import (
-    CreateFileBlock,
-    ExternalFile,
-    FileBlock,
-    FileType,
-    FileUploadFile,
-    NotionHostedFile,
-)
-
-__all__ = [
-    "FileElement",
-    "FileType",
-    "ExternalFile",
-    "NotionHostedFile",
-    "FileUploadFile",
-    "FileBlock",
-    "CreateFileBlock",
-    "FileMarkdownNode",
-]

notionary/blocks/file/file_element.py

@@ -1,133 +0,0 @@
-from __future__ import annotations
-
-import re
-from pathlib import Path
-from typing import Optional
-
-from notionary.blocks.base_block_element import BaseBlockElement
-from notionary.blocks.file.file_element_models import (
-    CreateFileBlock,
-    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
-
-
-class FileElement(BaseBlockElement, CaptionMixin, FileUploadMixin):
-    r"""
-    Handles conversion between Markdown file embeds and Notion file blocks.
-
-    Supports both external URLs and local file uploads.
-
-    Markdown file syntax:
-    - [file](https://example.com/document.pdf) - External URL
-    - [file](./local/document.pdf) - Local file (will be uploaded)
-    - [file](C:\Documents\report.pdf) - Absolute local path (will be uploaded)
-    - [file](https://example.com/document.pdf)(caption:Annual Report) - With caption
-    - (caption:Important document)[file](./doc.pdf) - Caption before URL
-    """
-
-    FILE_PATTERN = re.compile(r"\[file\]\(([^)]+)\)")
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        return bool(block.type == BlockType.FILE and block.file)
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> Optional[BlockCreateResult]:
-        """Convert markdown file link to Notion FileBlock."""
-        file_path = cls._extract_file_path(text.strip())
-        if not file_path:
-            return None
-
-        cls.logger.info(f"Processing file: {file_path}")
-
-        # Extract caption
-        caption_text = cls.extract_caption(text.strip())
-        caption_rich_text = cls.build_caption_rich_text(caption_text or "")
-
-        # Determine if it's a local file or external URL
-        if cls._is_local_file_path(file_path):
-            cls.logger.debug(f"Detected local file: {file_path}")
-
-            # Upload the local file using mixin method
-            file_upload_id = await cls._upload_local_file(file_path, "file")
-            if not file_upload_id:
-                cls.logger.error(f"Failed to upload file: {file_path}")
-                return None
-
-            # Create FILE_UPLOAD block
-            file_block = FileBlock(
-                type=FileType.FILE_UPLOAD,
-                file_upload=FileUploadFile(id=file_upload_id),
-                caption=caption_rich_text,
-                name=Path(file_path).name,
-            )
-
-        else:
-            cls.logger.debug(f"Using external URL: {file_path}")
-
-            file_block = FileBlock(
-                type=FileType.EXTERNAL,
-                external=ExternalFile(url=file_path),
-                caption=caption_rich_text,
-            )
-
-        return CreateFileBlock(file=file_block)
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        if block.type != BlockType.FILE or not block.file:
-            return None
-
-        fb: FileBlock = block.file
-
-        # Determine the source for markdown
-        if fb.type == FileType.EXTERNAL and fb.external:
-            source = fb.external.url
-        elif fb.type == FileType.FILE and fb.file:
-            source = fb.file.url
-        else:
-            return None
-
-        result = f"[file]({source})"
-
-        # Add caption if present
-        caption_markdown = await cls.format_caption_for_markdown(fb.caption or [])
-        if caption_markdown:
-            result += caption_markdown
-
-        return result
-
-    @classmethod
-    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """Get system prompt information for file blocks."""
-        return BlockElementMarkdownInformation(
-            block_type=cls.__name__,
-            description="File blocks embed files from external URLs or upload local files with optional captions",
-            syntax_examples=[
-                "[file](https://example.com/document.pdf)",
-                "[file](./local/document.pdf)",
-                "[file](C:\\Documents\\report.xlsx)",
-                "[file](https://example.com/document.pdf)(caption:Annual Report)",
-                "(caption:Q1 Data)[file](./spreadsheet.xlsx)",
-                "[file](./manual.docx)(caption:**User** manual)",
-            ],
-            usage_guidelines="Use for both external URLs and local files. Local files will be automatically uploaded to Notion. Supports various file formats including PDFs, documents, spreadsheets, images. Caption supports rich text formatting and should describe the file content or purpose.",
-        )
-
-    @classmethod
-    def _extract_file_path(cls, text: str) -> Optional[str]:
-        """Extract file path/URL from text, handling caption patterns."""
-        clean_text = cls.remove_caption(text)
-
-        match = cls.FILE_PATTERN.search(clean_text)
-        if match:
-            return match.group(1).strip()
-
-        return None

notionary/blocks/file/file_element_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 FileMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
-    """
-    Enhanced File node with Pydantic integration.
-    Programmatic interface for creating Notion-style Markdown file embeds.
-    """
-
-    url: str
-    caption: Optional[str] = None
-
-    def to_markdown(self) -> str:
-        """Return the Markdown representation.
-
-        Examples:
-        - [file](https://example.com/document.pdf)
-        - [file](https://example.com/document.pdf)(caption:User manual)
-        """
-        base_markdown = f"[file]({self.url})"
-        return self.append_caption_to_markdown(base_markdown, self.caption)

notionary/blocks/file/file_element_models.py

@@ -1,39 +0,0 @@
-from enum import Enum
-from typing import Literal, Optional
-
-from pydantic import BaseModel, Field
-
-from notionary.blocks.rich_text.rich_text_models import RichTextObject
-
-
-class FileType(str, Enum):
-    EXTERNAL = "external"
-    FILE = "file"
-    FILE_UPLOAD = "file_upload"
-
-
-class ExternalFile(BaseModel):
-    url: str
-
-
-class NotionHostedFile(BaseModel):
-    url: str
-    expiry_time: str
-
-
-class FileUploadFile(BaseModel):
-    id: str
-
-
-class FileBlock(BaseModel):
-    caption: list[RichTextObject] = Field(default_factory=list)
-    type: FileType
-    external: Optional[ExternalFile] = None
-    file: Optional[NotionHostedFile] = None
-    file_upload: Optional[FileUploadFile] = None
-    name: Optional[str] = None
-
-
-class CreateFileBlock(BaseModel):
-    type: Literal["file"] = "file"
-    file: FileBlock

notionary/blocks/heading/__init__.py

@@ -1,19 +0,0 @@
-from notionary.blocks.heading.heading_element import HeadingElement
-from notionary.blocks.heading.heading_markdown_node import (
-    HeadingMarkdownNode,
-)
-from notionary.blocks.heading.heading_models import (
-    CreateHeading1Block,
-    CreateHeading2Block,
-    CreateHeading3Block,
-    HeadingBlock,
-)
-
-__all__ = [
-    "HeadingElement",
-    "HeadingBlock",
-    "CreateHeading1Block",
-    "CreateHeading2Block",
-    "CreateHeading3Block",
-    "HeadingMarkdownNode",
-]

notionary/blocks/heading/heading_element.py

@@ -1,112 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import Optional, cast
-
-from notionary.blocks.base_block_element import BaseBlockElement
-from notionary.blocks.heading.heading_models import (
-    CreateHeading1Block,
-    CreateHeading2Block,
-    CreateHeading3Block,
-    HeadingBlock,
-)
-from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
-from notionary.blocks.models import Block, BlockCreateResult, BlockType
-from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
-from notionary.blocks.types import BlockColor
-
-
-class HeadingElement(BaseBlockElement):
-    """Handles conversion between Markdown headings and Notion heading blocks."""
-
-    PATTERN = re.compile(r"^(#{1,3})[ \t]+(.+)$")
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        return (
-            block.type
-            in (
-                BlockType.HEADING_1,
-                BlockType.HEADING_2,
-                BlockType.HEADING_3,
-            )
-            and getattr(block, block.type.value) is not None
-        )
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
-        """Convert markdown headings (#, ##, ###) to Notion HeadingBlock."""
-        match = cls.PATTERN.match(text.strip())
-        if not match:
-            return None
-
-        level = len(match.group(1))
-        if level < 1 or level > 3:
-            return None
-
-        content = match.group(2).strip()
-        if not content:
-            return None
-
-        rich_text = await TextInlineFormatter.parse_inline_formatting(content)
-        heading_content = HeadingBlock(
-            rich_text=rich_text, color=BlockColor.DEFAULT, is_toggleable=False
-        )
-
-        if level == 1:
-            return CreateHeading1Block(heading_1=heading_content)
-        elif level == 2:
-            return CreateHeading2Block(heading_2=heading_content)
-        else:
-            return CreateHeading3Block(heading_3=heading_content)
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        # Only handle heading blocks via BlockType enum
-        if block.type not in (
-            BlockType.HEADING_1,
-            BlockType.HEADING_2,
-            BlockType.HEADING_3,
-        ):
-            return None
-
-        # Determine heading level from enum
-        if block.type == BlockType.HEADING_1:
-            level = 1
-        elif block.type == BlockType.HEADING_2:
-            level = 2
-        else:
-            level = 3
-
-        heading_obj = getattr(block, block.type.value)
-        if not heading_obj:
-            return None
-
-        heading_data = cast(HeadingBlock, heading_obj)
-        if not heading_data.rich_text:
-            return None
-
-        text = await TextInlineFormatter.extract_text_with_formatting(
-            heading_data.rich_text
-        )
-        if not text:
-            return None
-
-        # Use hash-style for all heading levels
-        return f"{('#' * level)} {text}"
-
-    @classmethod
-    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """Get system prompt information for heading blocks."""
-        return BlockElementMarkdownInformation(
-            block_type=cls.__name__,
-            description="Heading blocks create hierarchical document structure with different levels",
-            syntax_examples=[
-                "# Heading Level 1",
-                "## Heading Level 2",
-                "### Heading Level 3",
-                "# Heading with **bold text**",
-                "## Heading with *italic text*",
-            ],
-            usage_guidelines="Use # for main titles, ## for sections, ### for subsections. Supports inline formatting. Only levels 1-3 are supported in Notion.",
-        )

notionary/blocks/heading/heading_markdown_node.py

@@ -1,16 +0,0 @@
-from pydantic import Field
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-
-
-class HeadingMarkdownNode(MarkdownNode):
-    """
-    Enhanced Heading node with Pydantic integration.
-    Programmatic interface for creating Markdown headings (H1-H3).
-    Example: # Heading 1, ## Heading 2, ### Heading 3
-    """
-
-    text: str
-    level: int = Field(default=1, ge=1, le=3)
-
-    def to_markdown(self) -> str:
-        return f"{'#' * self.level} {self.text}"