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

notionary/blocks/mixins/file_upload/file_upload_mixin.py

@@ -1,320 +0,0 @@
-from urllib.parse import urlparse
-from pathlib import Path
-from typing import Optional
-from notionary.file_upload import NotionFileUploadClient
-from notionary.file_upload.models import UploadMode
-from notionary.page.page_context import get_page_context
-from notionary.util.logging_mixin import LoggingMixin
-
-
-# TOOD: Hier überlegen wirklich nur was common ist hier in den mixin ansonstne dediziert handeln.
-class FileUploadMixin(LoggingMixin):
-    """
-    Mixin to add file upload functionality to all media block elements.
-
-    Supports uploading local files for:
-    - file blocks
-    - image blocks
-    - pdf blocks
-    - audio blocks
-    - video blocks
-    """
-
-    @classmethod
-    def _get_file_upload_client(cls) -> NotionFileUploadClient:
-        """Get the file upload client from the current page context."""
-        context = get_page_context()
-        return context.file_upload_client
-
-    @classmethod
-    def _is_local_file_path(cls, path: str) -> bool:
-        """Determine if the path is a local file rather than a URL."""
-        if path.startswith(("http://", "https://", "ftp://")):
-            return False
-
-        return (
-            "/" in path
-            or "\\" in path
-            or path.startswith("./")
-            or path.startswith("../")
-            or ":" in path[:3]
-        )  # Windows drive letters like C:
-
-    @classmethod
-    def _should_upload_file(cls, path: str, expected_category: str = "file") -> bool:
-        """
-        Determine if a path should be uploaded vs used as external URL.
-
-        Args:
-            path: File path or URL
-            expected_category: Expected file category
-
-        Returns:
-            True if file should be uploaded
-        """
-        if not cls._is_local_file_path(path):
-            return False
-
-        file_path = Path(path)
-        if not file_path.exists():
-            return False
-
-        return True
-
-    @classmethod
-    def _get_content_type(cls, file_path: Path) -> str:
-        """Get MIME type based on file extension."""
-        extension_map = {
-            # Documents
-            ".pdf": "application/pdf",
-            ".doc": "application/msword",
-            ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-            ".xls": "application/vnd.ms-excel",
-            ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-            ".ppt": "application/vnd.ms-powerpoint",
-            ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-            ".txt": "text/plain",
-            ".csv": "text/csv",
-            ".json": "application/json",
-            ".xml": "application/xml",
-            ".zip": "application/zip",
-            ".rar": "application/vnd.rar",
-            ".7z": "application/x-7z-compressed",
-            # Images
-            ".png": "image/png",
-            ".jpg": "image/jpeg",
-            ".jpeg": "image/jpeg",
-            ".gif": "image/gif",
-            ".webp": "image/webp",
-            ".bmp": "image/bmp",
-            ".tiff": "image/tiff",
-            ".tif": "image/tiff",
-            ".svg": "image/svg+xml",
-            ".ico": "image/x-icon",
-            ".heic": "image/heic",
-            ".heif": "image/heif",
-            # Audio
-            ".mp3": "audio/mpeg",
-            ".wav": "audio/wav",
-            ".ogg": "audio/ogg",
-            ".m4a": "audio/mp4",
-            ".aac": "audio/aac",
-            ".flac": "audio/flac",
-            ".wma": "audio/x-ms-wma",
-            ".opus": "audio/opus",
-            # Video
-            ".mp4": "video/mp4",
-            ".avi": "video/x-msvideo",
-            ".mov": "video/quicktime",
-            ".wmv": "video/x-ms-wmv",
-            ".flv": "video/x-flv",
-            ".webm": "video/webm",
-            ".mkv": "video/x-matroska",
-            ".m4v": "video/mp4",
-            ".3gp": "video/3gpp",
-        }
-
-        suffix = file_path.suffix.lower()
-        return extension_map.get(suffix, "application/octet-stream")
-
-    @classmethod
-    def _get_file_category(cls, file_path: Path) -> str:
-        """
-        Determine the category of file based on extension.
-
-        Returns:
-            One of: 'image', 'audio', 'video', 'pdf', 'document', 'archive', 'other'
-        """
-        suffix = file_path.suffix.lower()
-
-        # Define extension sets for each category
-        extension_categories = {
-            "image": {
-                ".png",
-                ".jpg",
-                ".jpeg",
-                ".gif",
-                ".webp",
-                ".bmp",
-                ".tiff",
-                ".tif",
-                ".svg",
-                ".ico",
-                ".heic",
-                ".heif",
-            },
-            "audio": {".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac", ".wma", ".opus"},
-            "video": {
-                ".mp4",
-                ".avi",
-                ".mov",
-                ".wmv",
-                ".flv",
-                ".webm",
-                ".mkv",
-                ".m4v",
-                ".3gp",
-            },
-            "pdf": {".pdf"},
-            "document": {
-                ".doc",
-                ".docx",
-                ".xls",
-                ".xlsx",
-                ".ppt",
-                ".pptx",
-                ".txt",
-                ".csv",
-                ".json",
-                ".xml",
-            },
-            "archive": {".zip", ".rar", ".7z"},
-        }
-
-        # Find matching category
-        for category, extensions in extension_categories.items():
-            if suffix in extensions:
-                return category
-
-        return "other"
-
-    @classmethod
-    def _is_supported_file_type(cls, file_path: Path, expected_category: str) -> bool:
-        """
-        Check if the file type matches the expected category.
-
-        Args:
-            file_path: Path to the file
-            expected_category: Expected category ('image', 'audio', 'video', 'pdf', 'file')
-
-        Returns:
-            True if file type matches expected category
-        """
-        # 'file' category accepts any file type
-        if expected_category == "file":
-            return True
-
-        actual_category = cls._get_file_category(file_path)
-        return actual_category == expected_category
-
-    @classmethod
-    async def _upload_local_file(
-        cls, file_path_str: str, expected_category: str = "file"
-    ) -> Optional[str]:
-        """
-        Upload a local file and return the file upload ID.
-
-        Args:
-            file_path_str: String path to the local file
-            expected_category: Expected file category for validation
-
-        Returns:
-            File upload ID if successful, None otherwise
-        """
-        try:
-            file_upload_client = cls._get_file_upload_client()
-            file_path = Path(file_path_str)
-
-            # Pre-upload validation
-            if not cls._validate_file_for_upload(file_path, expected_category):
-                return None
-
-            # Get file metadata
-            file_size = file_path.stat().st_size
-            content_type = cls._get_content_type(file_path)
-
-            cls.logger.info(
-                f"Uploading {expected_category} file: {file_path.name} "
-                f"({file_size} bytes, {content_type})"
-            )
-
-            # Create and execute upload
-            upload_id = await cls._execute_upload(
-                file_upload_client, file_path, content_type, file_size
-            )
-
-            if upload_id:
-                cls.logger.info(
-                    f"File upload completed: {upload_id} ({file_path.name})"
-                )
-
-            return upload_id
-
-        except Exception as e:
-            cls.logger.error(
-                f"Error uploading {expected_category} file {file_path_str}: {e}"
-            )
-            cls.logger.debug("Upload error traceback:", exc_info=True)
-            return None
-
-    @classmethod
-    def _validate_file_for_upload(cls, file_path: Path, expected_category: str) -> bool:
-        """Validate file exists and type matches expected category."""
-        # Check if file exists
-        if not file_path.exists():
-            cls.logger.error(f"File not found: {file_path}")
-            return False
-
-        # Validate file type if needed
-        if not cls._is_supported_file_type(file_path, expected_category):
-            actual_category = cls._get_file_category(file_path)
-            cls.logger.warning(
-                f"File type mismatch: expected {expected_category}, "
-                f"got {actual_category} for {file_path} - proceeding anyway"
-            )
-
-        return True
-
-    @classmethod
-    async def _execute_upload(
-        cls,
-        file_upload_client: NotionFileUploadClient,
-        file_path: Path,
-        content_type: str,
-        file_size: int,
-    ) -> Optional[str]:
-        """Execute the actual file upload process."""
-        # Step 1: Create file upload
-        upload_response = await file_upload_client.create_file_upload(
-            filename=file_path.name,
-            content_type=content_type,
-            content_length=file_size,
-            mode=UploadMode.SINGLE_PART,
-        )
-
-        if not upload_response:
-            cls.logger.error(f"Failed to create file upload for {file_path.name}")
-            return None
-
-        cls.logger.debug(f"Created file upload with ID: {upload_response.id}")
-
-        # Step 2: Send file content
-        success = await file_upload_client.send_file_from_path(
-            file_upload_id=upload_response.id, file_path=file_path
-        )
-
-        if not success:
-            cls.logger.error(f"Failed to send file content for {file_path.name}")
-            return None
-
-        cls.logger.debug(f"File content sent successfully for {file_path.name}")
-        return upload_response.id
-
-    @classmethod
-    def _get_upload_error_message(
-        cls, file_path_str: str, expected_category: str
-    ) -> str:
-        """Get a user-friendly error message for upload failures."""
-        file_path = Path(file_path_str)
-
-        if not file_path.exists():
-            return f"File not found: {file_path_str}"
-
-        actual_category = cls._get_file_category(file_path)
-        if actual_category != expected_category and expected_category != "file":
-            return (
-                f"Invalid file type for {expected_category} block: "
-                f"{file_path.suffix} (detected as {actual_category})"
-            )
-
-        return f"Failed to upload {expected_category} file: {file_path_str}"

notionary/blocks/models.py

@@ -1,174 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Literal, Optional, Union
-
-from pydantic import BaseModel
-
-from notionary.blocks.types import BlockType
-
-if TYPE_CHECKING:
-    from notionary.blocks.bookmark import BookmarkBlock, CreateBookmarkBlock
-    from notionary.blocks.breadcrumbs import BreadcrumbBlock, CreateBreadcrumbBlock
-    from notionary.blocks.bulleted_list import (
-        BulletedListItemBlock,
-        CreateBulletedListItemBlock,
-    )
-    from notionary.blocks.callout import CalloutBlock, CreateCalloutBlock
-    from notionary.blocks.child_page import ChildPageBlock, CreateChildPageBlock
-    from notionary.blocks.code import CodeBlock, CreateCodeBlock
-    from notionary.blocks.column import (
-        ColumnBlock,
-        ColumnListBlock,
-        CreateColumnBlock,
-        CreateColumnListBlock,
-    )
-    from notionary.blocks.divider import CreateDividerBlock, DividerBlock
-    from notionary.blocks.embed import CreateEmbedBlock, EmbedBlock
-    from notionary.blocks.equation import CreateEquationBlock, EquationBlock
-    from notionary.blocks.file import CreateFileBlock, FileBlock
-    from notionary.blocks.heading import (
-        CreateHeading1Block,
-        CreateHeading2Block,
-        CreateHeading3Block,
-        HeadingBlock,
-    )
-    from notionary.blocks.image_block import CreateImageBlock
-    from notionary.blocks.numbered_list import (
-        CreateNumberedListItemBlock,
-        NumberedListItemBlock,
-    )
-    from notionary.blocks.paragraph import CreateParagraphBlock, ParagraphBlock
-    from notionary.blocks.pdf import CreatePdfBlock
-    from notionary.blocks.quote import CreateQuoteBlock, QuoteBlock
-    from notionary.blocks.table import CreateTableBlock, TableBlock, TableRowBlock
-    from notionary.blocks.table_of_contents import (
-        CreateTableOfContentsBlock,
-        TableOfContentsBlock,
-    )
-    from notionary.blocks.todo import CreateToDoBlock, ToDoBlock
-    from notionary.blocks.toggle import CreateToggleBlock, ToggleBlock
-    from notionary.blocks.video import CreateVideoBlock
-    from notionary.blocks.child_database import ChildDatabaseBlock
-
-
-class BlockChildrenResponse(BaseModel):
-    object: Literal["list"]
-    results: list["Block"]
-    next_cursor: Optional[str] = None
-    has_more: bool
-    type: Literal["block"]
-    block: dict = {}
-    request_id: str
-
-
-class PageParent(BaseModel):
-    type: Literal["page_id"]
-    page_id: str
-
-
-class DatabaseParent(BaseModel):
-    type: Literal["database_id"]
-    database_id: str
-
-
-class BlockParent(BaseModel):
-    type: Literal["block_id"]
-    block_id: str
-
-
-class WorkspaceParent(BaseModel):
-    type: Literal["workspace"]
-    workspace: bool = True
-
-
-ParentObject = Union[PageParent, DatabaseParent, BlockParent, WorkspaceParent]
-
-
-class PartialUser(BaseModel):
-    object: Literal["user"]
-    id: str
-
-
-class Block(BaseModel):
-    object: Literal["block"]
-    id: str
-    parent: Optional[ParentObject] = None
-    type: BlockType
-    created_time: str
-    last_edited_time: str
-    created_by: PartialUser
-    last_edited_by: PartialUser
-    archived: bool = False
-    in_trash: bool = False
-    has_children: bool = False
-
-    children: Optional[list[Block]] = None
-
-    # Block type-specific content (only one will be populated based on type)
-    audio: Optional[FileBlock] = None
-    bookmark: Optional[BookmarkBlock] = None
-    breadcrumb: Optional[BreadcrumbBlock] = None
-    bulleted_list_item: Optional[BulletedListItemBlock] = None
-    callout: Optional[CalloutBlock] = None
-    child_page: Optional[ChildPageBlock] = None
-    code: Optional[CodeBlock] = None
-    column_list: Optional[ColumnListBlock] = None
-    column: Optional[ColumnBlock] = None
-    divider: Optional[DividerBlock] = None
-    embed: Optional[EmbedBlock] = None
-    equation: Optional[EquationBlock] = None
-    file: Optional[FileBlock] = None
-    heading_1: Optional[HeadingBlock] = None
-    heading_2: Optional[HeadingBlock] = None
-    heading_3: Optional[HeadingBlock] = None
-    image: Optional[FileBlock] = None
-    numbered_list_item: Optional[NumberedListItemBlock] = None
-    paragraph: Optional[ParagraphBlock] = None
-    quote: Optional[QuoteBlock] = None
-    table: Optional[TableBlock] = None
-    table_row: Optional[TableRowBlock] = None
-    to_do: Optional[ToDoBlock] = None
-    toggle: Optional[ToggleBlock] = None
-    video: Optional[FileBlock] = None
-    pdf: Optional[FileBlock] = None
-    table_of_contents: Optional[TableOfContentsBlock] = None
-    child_database: Optional[ChildDatabaseBlock] = None
-
-    def get_block_content(self) -> Optional[Any]:
-        """Get the content object for this block based on its type."""
-        return getattr(self, self.type, None)
-
-
-if TYPE_CHECKING:
-    BlockCreateRequest = Union[
-        CreateBookmarkBlock,
-        CreateBreadcrumbBlock,
-        CreateBulletedListItemBlock,
-        CreateCalloutBlock,
-        CreateChildPageBlock,
-        CreateCodeBlock,
-        CreateColumnListBlock,
-        CreateColumnBlock,
-        CreateDividerBlock,
-        CreateEmbedBlock,
-        CreateEquationBlock,
-        CreateFileBlock,
-        CreateHeading1Block,
-        CreateHeading2Block,
-        CreateHeading3Block,
-        CreateImageBlock,
-        CreateNumberedListItemBlock,
-        CreateParagraphBlock,
-        CreateQuoteBlock,
-        CreateToDoBlock,
-        CreateToggleBlock,
-        CreateVideoBlock,
-        CreateTableOfContentsBlock,
-        CreatePdfBlock,
-        CreateTableBlock,
-    ]
-    BlockCreateResult = Union[BlockCreateRequest]
-else:
-    # at runtime there are no typings anyway
-    BlockCreateRequest = Any
-    BlockCreateResult = Any

notionary/blocks/numbered_list/__init__.py

@@ -1,16 +0,0 @@
-from notionary.blocks.numbered_list.numbered_list_element import NumberedListElement
-from notionary.blocks.numbered_list.numbered_list_markdown_node import (
-    NumberedListMarkdownNode,
-)
-from notionary.blocks.numbered_list.numbered_list_models import (
-    CreateNumberedListItemBlock,
-    NumberedListItemBlock,
-)
-
-__all__ = [
-    "NumberedListElement",
-    "NumberedListItemBlock",
-    "CreateNumberedListItemBlock",
-    "NumberedListMarkdownNode",
-    "NumberedListMarkdownBlockParams",
-]

notionary/blocks/numbered_list/numbered_list_element.py

@@ -1,65 +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.numbered_list.numbered_list_models import (
-    CreateNumberedListItemBlock,
-    NumberedListItemBlock,
-)
-from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
-from notionary.blocks.types import BlockColor
-
-
-class NumberedListElement(BaseBlockElement):
-    """Converts between Markdown numbered lists and Notion numbered list items."""
-
-    PATTERN = re.compile(r"^\s*(\d+)\.\s+(.+)$")
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        return block.type == BlockType.NUMBERED_LIST_ITEM and block.numbered_list_item
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
-        """Convert markdown numbered list item to Notion NumberedListItemBlock."""
-        match = cls.PATTERN.match(text.strip())
-        if not match:
-            return None
-
-        content = match.group(2)
-        rich_text = await TextInlineFormatter.parse_inline_formatting(content)
-
-        numbered_list_content = NumberedListItemBlock(
-            rich_text=rich_text, color=BlockColor.DEFAULT
-        )
-        return CreateNumberedListItemBlock(numbered_list_item=numbered_list_content)
-
-    # FIX: Roundtrip conversions will never work this way here
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        if block.type != BlockType.NUMBERED_LIST_ITEM or not block.numbered_list_item:
-            return None
-
-        rich = block.numbered_list_item.rich_text
-        content = await TextInlineFormatter.extract_text_with_formatting(rich)
-        return f"1. {content}"
-
-    @classmethod
-    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """Get system prompt information for numbered list blocks."""
-        return BlockElementMarkdownInformation(
-            block_type=cls.__name__,
-            description="Numbered list items create ordered lists with sequential numbering",
-            syntax_examples=[
-                "1. First item",
-                "2. Second item",
-                "3. Third item",
-                "1. Item with **bold text**",
-                "1. Item with *italic text*",
-            ],
-            usage_guidelines="Use numbers followed by periods to create ordered lists. Supports inline formatting like bold, italic, and links. Numbering is automatically handled by Notion.",
-        )

notionary/blocks/numbered_list/numbered_list_markdown_node.py

@@ -1,17 +0,0 @@
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-
-
-class NumberedListMarkdownNode(MarkdownNode):
-    """
-    Enhanced NumberedList node with Pydantic integration.
-    Programmatic interface for creating Markdown numbered list items.
-    Example:
-    1. First step
-    2. Second step
-    3. Third step
-    """
-
-    texts: list[str]
-
-    def to_markdown(self) -> str:
-        return "\n".join(f"{i + 1}. {text}" for i, text in enumerate(self.texts))

notionary/blocks/numbered_list/numbered_list_models.py

@@ -1,17 +0,0 @@
-from pydantic import BaseModel
-from typing import Literal, Optional
-
-from notionary.blocks.models import Block
-from notionary.blocks.rich_text.rich_text_models import RichTextObject
-from notionary.blocks.types import BlockColor
-
-
-class NumberedListItemBlock(BaseModel):
-    rich_text: list[RichTextObject]
-    color: BlockColor = BlockColor.DEFAULT
-    children: Optional[list[Block]] = None
-
-
-class CreateNumberedListItemBlock(BaseModel):
-    type: Literal["numbered_list_item"] = "numbered_list_item"
-    numbered_list_item: NumberedListItemBlock

notionary/blocks/paragraph/__init__.py

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

notionary/blocks/paragraph/paragraph_element.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-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
-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(BaseBlockElement):
-    """
-    Handles conversion between Markdown paragraphs and Notion paragraph blocks.
-    """
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        return block.type == "paragraph" and block.paragraph
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
-        """Convert markdown text to a Notion ParagraphBlock."""
-        if not text.strip():
-            return None
-
-        rich = await TextInlineFormatter.parse_inline_formatting(text)
-
-        paragraph_content = ParagraphBlock(rich_text=rich, color=BlockColor.DEFAULT)
-        return CreateParagraphBlock(paragraph=paragraph_content)
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        if block.type != BlockType.PARAGRAPH or not block.paragraph:
-            return None
-
-        rich_list = block.paragraph.rich_text
-        markdown = await TextInlineFormatter.extract_text_with_formatting(rich_list)
-        return markdown or None
-
-    @classmethod
-    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """Get system prompt information for paragraph blocks."""
-        return BlockElementMarkdownInformation(
-            block_type=cls.__name__,
-            description="Paragraph blocks contain regular text content with optional inline formatting",
-            syntax_examples=[
-                "This is a simple paragraph.",
-                "Paragraph with **bold text** and *italic text*.",
-                "Paragraph with [link](https://example.com) and `code`.",
-                "Multiple sentences in one paragraph. Each sentence flows naturally.",
-            ],
-            usage_guidelines="Use for regular text content. Supports inline formatting: **bold**, *italic*, `code`, [links](url). Default block type for plain text.",
-        )