notionary 0.2.16__py3-none-any.whl → 0.2.18__py3-none-any.whl

notionary/file_upload/notion_file_upload.py

@@ -0,0 +1,387 @@
+import asyncio
+import mimetypes
+from typing import Optional
+from pathlib import Path
+from datetime import datetime, timedelta
+from io import BytesIO
+
+
+from notionary.file_upload.models import FileUploadResponse
+from notionary.util import LoggingMixin
+
+
+class NotionFileUpload(LoggingMixin):
+    """
+    High-level service for managing Notion file uploads.
+    Handles both small file (single-part) and large file (multi-part) uploads.
+    """
+
+    # Notion's file size limits
+    SINGLE_PART_MAX_SIZE = 20 * 1024 * 1024  # 20MB
+    MULTI_PART_CHUNK_SIZE = 10 * 1024 * 1024  # 10MB per part
+    MAX_FILENAME_BYTES = 900
+
+    def __init__(self, token: Optional[str] = None):
+        """Initialize the file upload service."""
+        from notionary.file_upload import NotionFileUploadClient
+
+        self.client = NotionFileUploadClient(token=token)
+
+    async def upload_file(
+        self, file_path: Path, filename: Optional[str] = None
+    ) -> Optional[FileUploadResponse]:
+        """
+        Upload a file to Notion, automatically choosing single-part or multi-part based on size.
+
+        Args:
+            file_path: Path to the file to upload
+            filename: Optional custom filename (defaults to file_path.name)
+
+        Returns:
+            FileUploadResponse if successful, None otherwise
+        """
+        if not file_path.exists():
+            self.logger.error("File does not exist: %s", file_path)
+            return None
+
+        file_size = file_path.stat().st_size
+        filename = filename or file_path.name
+
+        # Validate filename length
+        if len(filename.encode("utf-8")) > self.MAX_FILENAME_BYTES:
+            self.logger.error(
+                "Filename too long: %d bytes (max %d)",
+                len(filename.encode("utf-8")),
+                self.MAX_FILENAME_BYTES,
+            )
+            return None
+
+        # Choose upload method based on file size
+        if file_size <= self.SINGLE_PART_MAX_SIZE:
+            return await self._upload_small_file(file_path, filename, file_size)
+        else:
+            return await self._upload_large_file(file_path, filename, file_size)
+
+    async def upload_from_bytes(
+        self, file_content: bytes, filename: str, content_type: Optional[str] = None
+    ) -> Optional[FileUploadResponse]:
+        """
+        Upload file content from bytes.
+
+        Args:
+            file_content: File content as bytes
+            filename: Name for the file
+            content_type: Optional MIME type
+
+        Returns:
+            FileUploadResponse if successful, None otherwise
+        """
+        file_size = len(file_content)
+
+        # Validate filename length
+        if len(filename.encode("utf-8")) > self.MAX_FILENAME_BYTES:
+            self.logger.error(
+                "Filename too long: %d bytes (max %d)",
+                len(filename.encode("utf-8")),
+                self.MAX_FILENAME_BYTES,
+            )
+            return None
+
+        # Guess content type if not provided
+        if not content_type:
+            content_type, _ = mimetypes.guess_type(filename)
+
+        # Choose upload method based on size
+        if file_size <= self.SINGLE_PART_MAX_SIZE:
+            return await self._upload_small_file_from_bytes(
+                file_content, filename, content_type, file_size
+            )
+        else:
+            return await self._upload_large_file_from_bytes(
+                file_content, filename, content_type, file_size
+            )
+
+    async def get_upload_status(self, file_upload_id: str) -> Optional[str]:
+        """
+        Get the current status of a file upload.
+
+        Args:
+            file_upload_id: ID of the file upload
+
+        Returns:
+            Status string ("pending", "uploaded", etc.) or None if failed
+        """
+        upload_info = await self.client.retrieve_file_upload(file_upload_id)
+        return upload_info.status if upload_info else None
+
+    async def wait_for_upload_completion(
+        self, file_upload_id: str, timeout_seconds: int = 300, poll_interval: int = 2
+    ) -> Optional[FileUploadResponse]:
+        """
+        Wait for a file upload to complete.
+
+        Args:
+            file_upload_id: ID of the file upload
+            timeout_seconds: Maximum time to wait
+            poll_interval: Seconds between status checks
+
+        Returns:
+            FileUploadResponse when complete, None if timeout or failed
+        """
+        start_time = datetime.now()
+        timeout_delta = timedelta(seconds=timeout_seconds)
+
+        while datetime.now() - start_time < timeout_delta:
+            upload_info = await self.client.retrieve_file_upload(file_upload_id)
+
+            if not upload_info:
+                self.logger.error(
+                    "Failed to retrieve upload info for %s", file_upload_id
+                )
+                return None
+
+            if upload_info.status == "uploaded":
+                self.logger.info("Upload completed: %s", file_upload_id)
+                return upload_info
+            elif upload_info.status == "failed":
+                self.logger.error("Upload failed: %s", file_upload_id)
+                return None
+
+            await asyncio.sleep(poll_interval)
+
+        self.logger.warning("Upload timeout: %s", file_upload_id)
+        return None
+
+    async def list_recent_uploads(self, limit: int = 50) -> list[FileUploadResponse]:
+        """
+        List recent file uploads.
+
+        Args:
+            limit: Maximum number of uploads to return
+
+        Returns:
+            List of FileUploadResponse objects
+        """
+        uploads = []
+        start_cursor = None
+        remaining = limit
+
+        while remaining > 0:
+            page_size = min(remaining, 100)  # API max per request
+
+            response = await self.client.list_file_uploads(
+                page_size=page_size, start_cursor=start_cursor
+            )
+
+            if not response or not response.results:
+                break
+
+            uploads.extend(response.results)
+            remaining -= len(response.results)
+
+            if not response.has_more or not response.next_cursor:
+                break
+
+            start_cursor = response.next_cursor
+
+        return uploads[:limit]
+
+    async def _upload_small_file(
+        self, file_path: Path, filename: str, file_size: int
+    ) -> Optional[FileUploadResponse]:
+        """Upload a small file using single-part upload."""
+        content_type, _ = mimetypes.guess_type(str(file_path))
+
+        # Create file upload
+        file_upload = await self.client.create_file_upload(
+            filename=filename,
+            content_type=content_type,
+            content_length=file_size,
+            mode="single_part",
+        )
+
+        if not file_upload:
+            self.logger.error("Failed to create file upload for %s", filename)
+            return None
+
+        # Send file content
+        success = await self.client.send_file_from_path(
+            file_upload_id=file_upload.id, file_path=file_path
+        )
+
+        if not success:
+            self.logger.error("Failed to send file content for %s", filename)
+            return None
+
+        self.logger.info(
+            "Successfully uploaded file: %s (ID: %s)", filename, file_upload.id
+        )
+        return file_upload
+
+    async def _upload_large_file(
+        self, file_path: Path, filename: str, file_size: int
+    ) -> Optional[FileUploadResponse]:
+        """Upload a large file using multi-part upload."""
+        content_type, _ = mimetypes.guess_type(str(file_path))
+
+        # Create file upload with multi-part mode
+        file_upload = await self.client.create_file_upload(
+            filename=filename,
+            content_type=content_type,
+            content_length=file_size,
+            mode="multi_part",
+        )
+
+        if not file_upload:
+            self.logger.error(
+                "Failed to create multi-part file upload for %s", filename
+            )
+            return None
+
+        # Upload file in parts
+        success = await self._upload_file_parts(file_upload.id, file_path, file_size)
+
+        if not success:
+            self.logger.error("Failed to upload file parts for %s", filename)
+            return None
+
+        # Complete the upload
+        completed_upload = await self.client.complete_file_upload(file_upload.id)
+
+        if not completed_upload:
+            self.logger.error("Failed to complete file upload for %s", filename)
+            return None
+
+        self.logger.info(
+            "Successfully uploaded large file: %s (ID: %s)", filename, file_upload.id
+        )
+        return completed_upload
+
+    async def _upload_small_file_from_bytes(
+        self,
+        file_content: bytes,
+        filename: str,
+        content_type: Optional[str],
+        file_size: int,
+    ) -> Optional[FileUploadResponse]:
+        """Upload small file from bytes."""
+        # Create file upload
+        file_upload = await self.client.create_file_upload(
+            filename=filename,
+            content_type=content_type,
+            content_length=file_size,
+            mode="single_part",
+        )
+
+        if not file_upload:
+            return None
+
+        # Send file content
+        from io import BytesIO
+
+        success = await self.client.send_file_upload(
+            file_upload_id=file_upload.id,
+            file_content=BytesIO(file_content),
+            filename=filename,
+        )
+
+        return file_upload if success else None
+
+    async def _upload_large_file_from_bytes(
+        self,
+        file_content: bytes,
+        filename: str,
+        content_type: Optional[str],
+        file_size: int,
+    ) -> Optional[FileUploadResponse]:
+        """Upload large file from bytes using multi-part."""
+        # Create file upload
+        file_upload = await self.client.create_file_upload(
+            filename=filename,
+            content_type=content_type,
+            content_length=file_size,
+            mode="multi_part",
+        )
+
+        if not file_upload:
+            return None
+
+        # Upload in chunks
+        success = await self._upload_bytes_parts(file_upload.id, file_content)
+
+        if not success:
+            return None
+
+        # Complete the upload
+        return await self.client.complete_file_upload(file_upload.id)
+
+    async def _upload_file_parts(
+        self, file_upload_id: str, file_path: Path, file_size: int
+    ) -> bool:
+        """Upload file in parts for multi-part upload."""
+        part_number = 1
+        total_parts = (
+            file_size + self.MULTI_PART_CHUNK_SIZE - 1
+        ) // self.MULTI_PART_CHUNK_SIZE
+
+        try:
+            import aiofiles
+
+            async with aiofiles.open(file_path, "rb") as file:
+                while True:
+                    chunk = await file.read(self.MULTI_PART_CHUNK_SIZE)
+                    if not chunk:
+                        break
+
+                    success = await self.client.send_file_upload(
+                        file_upload_id=file_upload_id,
+                        file_content=BytesIO(chunk),
+                        filename=file_path.name,
+                        part_number=part_number,
+                    )
+
+                    if not success:
+                        self.logger.error(
+                            "Failed to upload part %d/%d", part_number, total_parts
+                        )
+                        return False
+
+                    self.logger.debug("Uploaded part %d/%d", part_number, total_parts)
+                    part_number += 1
+
+            self.logger.info("Successfully uploaded all %d parts", total_parts)
+            return True
+
+        except Exception as e:
+            self.logger.error("Error uploading file parts: %s", e)
+            return False
+
+    async def _upload_bytes_parts(
+        self, file_upload_id: str, file_content: bytes
+    ) -> bool:
+        """Upload bytes in parts for multi-part upload."""
+        part_number = 1
+        total_parts = (
+            len(file_content) + self.MULTI_PART_CHUNK_SIZE - 1
+        ) // self.MULTI_PART_CHUNK_SIZE
+
+        for i in range(0, len(file_content), self.MULTI_PART_CHUNK_SIZE):
+            chunk = file_content[i : i + self.MULTI_PART_CHUNK_SIZE]
+
+            success = await self.client.send_file_upload(
+                file_upload_id=file_upload_id,
+                file_content=BytesIO(chunk),
+                part_number=part_number,
+            )
+
+            if not success:
+                self.logger.error(
+                    "Failed to upload part %d/%d", part_number, total_parts
+                )
+                return False
+
+            self.logger.debug("Uploaded part %d/%d", part_number, total_parts)
+            part_number += 1
+
+        self.logger.info("Successfully uploaded all %d parts", total_parts)
+        return True

notionary/page/content/markdown_whitespace_processor.py

@@ -0,0 +1,80 @@
+class MarkdownWhitespaceProcessor:
+    """Helper class for processing markdown whitespace."""
+
+    def __init__(self):
+        self.processed_lines = []
+        self.in_code_block = False
+        self.current_code_block = []
+
+    def process_lines(self, lines: list[str]) -> str:
+        """Process all lines and return the processed markdown."""
+        self.processed_lines = []
+        self.in_code_block = False
+        self.current_code_block = []
+
+        for line in lines:
+            self._process_single_line(line)
+
+        # Handle unclosed code block
+        if self.in_code_block and self.current_code_block:
+            self._finish_code_block()
+
+        return "\n".join(self.processed_lines)
+
+    def _process_single_line(self, line: str) -> None:
+        """Process a single line of markdown."""
+        if self._is_code_block_marker(line):
+            self._handle_code_block_marker(line)
+            return
+
+        if self.in_code_block:
+            self.current_code_block.append(line)
+            return
+
+        # Regular text - remove leading whitespace
+        self.processed_lines.append(line.lstrip())
+
+    def _handle_code_block_marker(self, line: str) -> None:
+        """Handle code block start/end markers."""
+        if not self.in_code_block:
+            # Starting new code block
+            self.in_code_block = True
+            self.processed_lines.append(self._normalize_code_block_start(line))
+            self.current_code_block = []
+        else:
+            # Ending code block
+            self._finish_code_block()
+
+    def _finish_code_block(self) -> None:
+        """Finish processing current code block."""
+        self.processed_lines.extend(
+            self._normalize_code_block_content(self.current_code_block)
+        )
+        self.processed_lines.append("```")
+        self.in_code_block = False
+
+    def _is_code_block_marker(self, line: str) -> bool:
+        """Check if line is a code block marker."""
+        return line.lstrip().startswith("```")
+
+    def _normalize_code_block_start(self, line: str) -> str:
+        """Normalize code block opening marker."""
+        language = line.lstrip().replace("```", "", 1).strip()
+        return "```" + language
+
+    def _normalize_code_block_content(self, code_lines: list[str]) -> list[str]:
+        """Normalize code block indentation."""
+        if not code_lines:
+            return []
+
+        # Find minimum indentation from non-empty lines
+        non_empty_lines = [line for line in code_lines if line.strip()]
+        if not non_empty_lines:
+            return [""] * len(code_lines)
+
+        min_indent = min(len(line) - len(line.lstrip()) for line in non_empty_lines)
+        if min_indent == 0:
+            return code_lines
+
+        # Remove common indentation
+        return ["" if not line.strip() else line[min_indent:] for line in code_lines]

notionary/page/content/notion_text_length_utils.py

@@ -0,0 +1,87 @@
+"""
+Utility functions for handling Notion API text length limitations.
+
+This module provides functions to fix text content that exceeds Notion's
+rich_text character limit of 2000 characters per element.
+
+Resolves API errors like:
+"validation_error - body.children[79].toggle.children[2].paragraph.rich_text[0].text.content.length
+should be ≤ 2000, instead was 2162."
+"""
+
+import re
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def fix_blocks_content_length(
+    blocks: list[dict[str, Any]], max_text_length: int = 1900
+) -> list[dict[str, Any]]:
+    """Check each block and ensure text content doesn't exceed Notion's limit."""
+    return [_fix_single_block_content(block, max_text_length) for block in blocks]
+
+
+def _fix_single_block_content(
+    block: dict[str, Any], max_text_length: int
+) -> dict[str, Any]:
+    """Fix content length in a single block and its children recursively."""
+    block_copy = block.copy()
+
+    block_type = block.get("type")
+    if not block_type:
+        return block_copy
+
+    content = block.get(block_type)
+    if not content:
+        return block_copy
+
+    if "rich_text" in content:
+        _fix_rich_text_content(block_copy, block_type, content, max_text_length)
+
+    if "children" in content and content["children"]:
+        block_copy[block_type]["children"] = [
+            _fix_single_block_content(child, max_text_length)
+            for child in content["children"]
+        ]
+
+    return block_copy
+
+
+def _fix_rich_text_content(
+    block_copy: dict[str, Any],
+    block_type: str,
+    content: dict[str, Any],
+    max_text_length: int,
+) -> None:
+    """Fix rich text content that exceeds the length limit."""
+    rich_text = content["rich_text"]
+    for i, text_item in enumerate(rich_text):
+        if "text" not in text_item or "content" not in text_item["text"]:
+            continue
+
+        text_content = text_item["text"]["content"]
+        if len(text_content) <= max_text_length:
+            continue
+
+        logger.warning(
+            "Truncating text content from %d to %d chars",
+            len(text_content),
+            max_text_length,
+        )
+        block_copy[block_type]["rich_text"][i]["text"]["content"] = text_content[
+            :max_text_length
+        ]
+
+
+def split_to_paragraphs(markdown_text: str) -> list[str]:
+    """Split markdown into paragraphs."""
+    paragraphs = re.split(r"\n\s*\n", markdown_text)
+    return [p for p in paragraphs if p.strip()]
+
+
+def split_to_sentences(paragraph: str) -> list[str]:
+    """Split a paragraph into sentences."""
+    sentences = re.split(r"(?<=[.!?])\s+", paragraph)
+    return [s for s in sentences if s.strip()]

notionary/page/content/page_content_retriever.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 
 from notionary.blocks.registry.block_registry import BlockRegistry
 
@@ -27,7 +27,7 @@ class PageContentRetriever(LoggingMixin):
 
     async def _get_page_blocks_with_children(
         self, parent_id: Optional[str] = None
-    ) -> List[Dict[str, Any]]:
+    ) -> list[Dict[str, Any]]:
         blocks = (
             await self.client.get_page_blocks(page_id=self.page_id)
             if parent_id is None