notionary 0.3.1__py3-none-any.whl → 0.4.1__py3-none-any.whl

notionary/file_upload/service.py

@@ -1,351 +1,242 @@
 import asyncio
 import mimetypes
-from datetime import datetime, timedelta
-from io import BytesIO
+from collections.abc import AsyncGenerator, AsyncIterator, Callable
 from pathlib import Path
 
-from notionary.file_upload.models import FileUploadResponse, UploadMode
+from notionary.exceptions.file_upload import UploadFailedError, UploadTimeoutError
+from notionary.file_upload.client import FileUploadHttpClient
+from notionary.file_upload.config import NOTION_SINGLE_PART_MAX_SIZE, FileUploadConfig
+from notionary.file_upload.file.reader import FileContentReader
+from notionary.file_upload.query import FileUploadQuery, FileUploadQueryBuilder
+from notionary.file_upload.schemas import FileUploadResponse, FileUploadStatus
+from notionary.file_upload.validation.factory import (
+    create_bytes_upload_validation_service,
+    create_file_upload_validation_service,
+)
 from notionary.utils.mixins.logging 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: str | None = None):
-        """Initialize the file upload service."""
-        from notionary.file_upload import FileUploadHttpClient
-
-        self.client = FileUploadHttpClient(token=token)
-
-    async def upload_file(self, file_path: Path, filename: str | None = None) -> FileUploadResponse | None:
-        """
-        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
+    def __init__(
+        self,
+        client: FileUploadHttpClient | None = None,
+        config: FileUploadConfig | None = None,
+        file_reader: FileContentReader | None = None,
+    ):
+        self._client = client or FileUploadHttpClient()
+        self._config = config or FileUploadConfig()
+        self._file_reader = file_reader or FileContentReader(config=self._config)
+
+    async def upload_file(
+        self, file_path: Path, filename: str | None = None
+    ) -> FileUploadResponse:
+        file_path = Path(file_path)
+
+        if not file_path.is_absolute() and self._config.base_upload_path:
+            file_path = Path(self._config.base_upload_path) / file_path
+        file_path = file_path.resolve()
+
+        validator_service = create_file_upload_validation_service(file_path)
+        await validator_service.validate()
 
         file_size = file_path.stat().st_size
         filename = filename or file_path.name
+        content_type = self._guess_content_type(filename)
 
-        # 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,
+        if self._fits_in_single_part(file_size):
+            content = await self._file_reader.read_full_file(file_path)
+            return await self._upload_single_part_content(
+                content, filename, content_type
             )
-            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)
+            return await self._upload_multi_part_content(
+                filename,
+                content_type,
+                file_size,
+                self._file_reader.read_file_chunks(file_path),
+            )
 
     async def upload_from_bytes(
-        self, file_content: bytes, filename: str, content_type: str | None = None
-    ) -> FileUploadResponse | None:
-        """
-        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
-        """
+        self,
+        file_content: bytes,
+        filename: str,
+        content_type: str | None = None,
+    ) -> FileUploadResponse:
         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) -> str | None:
-        """
-        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
-    ) -> FileUploadResponse | None:
-        """
-        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) -> FileUploadResponse | None:
-        """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(
+        validator_service = create_bytes_upload_validation_service(
             filename=filename,
-            content_type=content_type,
-            content_length=file_size,
-            mode=UploadMode.SINGLE_PART,
+            file_size_bytes=file_size,
         )
+        await validator_service.validate()
 
-        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)
+        content_type = content_type or self._guess_content_type(filename)
 
-        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) -> FileUploadResponse | None:
-        """Upload a large file using multi-part upload."""
-        content_type, _ = mimetypes.guess_type(str(file_path))
+        if self._fits_in_single_part(file_size):
+            return await self._upload_single_part_content(
+                file_content, filename, content_type
+            )
 
-        # 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=UploadMode.MULTI_PART,
+        return await self._upload_multi_part_content(
+            filename,
+            content_type,
+            file_size,
+            self._file_reader.bytes_to_chunks(file_content),
         )
 
-        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: str | None,
-        file_size: int,
-    ) -> FileUploadResponse | None:
-        """Upload small file from bytes."""
-        # Create file upload
-        file_upload = await self.client.create_file_upload(
+    async def _upload_single_part_content(
+        self, content: bytes, filename: str, content_type: str | None
+    ) -> FileUploadResponse:
+        file_upload = await self._client.create_single_part_upload(
             filename=filename,
             content_type=content_type,
-            content_length=file_size,
-            mode=UploadMode.SINGLE_PART,
         )
 
-        if not file_upload:
-            return None
-
-        # Send file content
-        from io import BytesIO
-
-        success = await self.client.send_file_upload(
+        await self._client.send_file_content(
             file_upload_id=file_upload.id,
-            file_content=BytesIO(file_content),
+            file_content=content,
             filename=filename,
         )
 
-        return file_upload if success else None
+        self.logger.info(
+            "Single-part content sent, waiting for completion... (ID: %s)",
+            file_upload.id,
+        )
+        return await self._wait_for_completion(file_upload.id)
 
-    async def _upload_large_file_from_bytes(
+    async def _upload_multi_part_content(
         self,
-        file_content: bytes,
         filename: str,
         content_type: str | None,
         file_size: int,
-    ) -> FileUploadResponse | None:
-        """Upload large file from bytes using multi-part."""
-        # Create file upload
-        file_upload = await self.client.create_file_upload(
+        chunk_generator: AsyncGenerator[bytes],
+    ) -> FileUploadResponse:
+        part_count = self._calculate_part_count(file_size)
+
+        file_upload = await self._client.create_multi_part_upload(
             filename=filename,
             content_type=content_type,
-            content_length=file_size,
-            mode=UploadMode.MULTI_PART,
+            number_of_parts=part_count,
         )
 
-        if not file_upload:
-            return None
+        await self._send_parts(file_upload.id, filename, part_count, chunk_generator)
 
-        # Upload in chunks
-        success = await self._upload_bytes_parts(file_upload.id, file_content)
+        await self._client.complete_upload(file_upload.id)
 
-        if not success:
-            return None
-
-        # Complete the upload
-        return await self.client.complete_file_upload(file_upload.id)
+        self.logger.info(
+            "Multi-part content sent, waiting for completion... (ID: %s)",
+            file_upload.id,
+        )
+        return await self._wait_for_completion(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."""
+    async def _send_parts(
+        self,
+        file_upload_id: str,
+        filename: str,
+        total_parts: int,
+        chunk_generator: AsyncGenerator[bytes],
+    ) -> None:
         part_number = 1
-        total_parts = (file_size + self.MULTI_PART_CHUNK_SIZE - 1) // self.MULTI_PART_CHUNK_SIZE
-
         try:
-            import aiofiles
+            async for chunk in chunk_generator:
+                await self._client.send_file_content(
+                    file_upload_id=file_upload_id,
+                    file_content=chunk,
+                    filename=filename,
+                    part_number=part_number,
+                )
 
-            async with aiofiles.open(file_path, "rb") as file:
-                while True:
-                    chunk = await file.read(self.MULTI_PART_CHUNK_SIZE)
-                    if not chunk:
-                        break
+                self.logger.debug("Uploaded part %d/%d", part_number, total_parts)
+                part_number += 1
 
-                    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,
-                    )
+        except Exception as e:
+            raise UploadFailedError(
+                file_upload_id=file_upload_id,
+                reason=f"Failed to upload part {part_number}/{total_parts}: {e}",
+            ) from e
 
-                    if not success:
-                        self.logger.error("Failed to upload part %d/%d", part_number, total_parts)
-                        return False
+    def _fits_in_single_part(self, file_size: int) -> bool:
+        return file_size <= NOTION_SINGLE_PART_MAX_SIZE
 
-                    self.logger.debug("Uploaded part %d/%d", part_number, total_parts)
-                    part_number += 1
+    def _guess_content_type(self, filename: str) -> str | None:
+        content_type, _ = mimetypes.guess_type(filename)
+        return content_type
 
-            self.logger.info("Successfully uploaded all %d parts", total_parts)
-            return True
+    def _calculate_part_count(self, file_size: int) -> int:
+        return (
+            file_size + self._config.multi_part_chunk_size - 1
+        ) // self._config.multi_part_chunk_size
 
+    async def get_upload_status(self, file_upload_id: str) -> str:
+        try:
+            upload_info = await self._client.get_file_upload(file_upload_id)
+            return upload_info.status
         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
+            raise UploadFailedError(file_upload_id, reason=str(e)) from e
 
-        for i in range(0, len(file_content), self.MULTI_PART_CHUNK_SIZE):
-            chunk = file_content[i : i + self.MULTI_PART_CHUNK_SIZE]
+    async def _wait_for_completion(
+        self,
+        file_upload_id: str,
+        timeout_seconds: int | None = None,
+    ) -> FileUploadResponse:
+        timeout = timeout_seconds or self._config.max_upload_timeout
 
-            success = await self.client.send_file_upload(
-                file_upload_id=file_upload_id,
-                file_content=BytesIO(chunk),
-                part_number=part_number,
+        try:
+            return await asyncio.wait_for(
+                self._poll_status_until_complete(file_upload_id), timeout=timeout
             )
 
-            if not success:
-                self.logger.error("Failed to upload part %d/%d", part_number, total_parts)
-                return False
+        except TimeoutError as e:
+            raise UploadTimeoutError(file_upload_id, timeout) from e
+
+    async def _poll_status_until_complete(
+        self, file_upload_id: str
+    ) -> FileUploadResponse:
+        while True:
+            upload_info = await self._client.get_file_upload(file_upload_id)
+
+            if upload_info.status == FileUploadStatus.UPLOADED:
+                self.logger.info("Upload completed: %s", file_upload_id)
+                return upload_info
 
-            self.logger.debug("Uploaded part %d/%d", part_number, total_parts)
-            part_number += 1
+            if upload_info.status == FileUploadStatus.FAILED:
+                raise UploadFailedError(file_upload_id)
 
-        self.logger.info("Successfully uploaded all %d parts", total_parts)
-        return True
+            await asyncio.sleep(self._config.poll_interval)
+
+    async def get_uploads(
+        self,
+        *,
+        filter_fn: Callable[[FileUploadQueryBuilder], FileUploadQueryBuilder]
+        | None = None,
+        query: FileUploadQuery | None = None,
+    ) -> list[FileUploadResponse]:
+        resolved_query = self._resolve_query(filter_fn=filter_fn, query=query)
+        return await self._client.list_file_uploads(query=resolved_query)
+
+    async def iter_uploads(
+        self,
+        *,
+        filter_fn: Callable[[FileUploadQueryBuilder], FileUploadQueryBuilder]
+        | None = None,
+        query: FileUploadQuery | None = None,
+    ) -> AsyncIterator[FileUploadResponse]:
+        resolved_query = self._resolve_query(filter_fn=filter_fn, query=query)
+        async for upload in self._client.list_file_uploads_stream(query=resolved_query):
+            yield upload
+
+    def _resolve_query(
+        self,
+        filter_fn: Callable[[FileUploadQueryBuilder], FileUploadQueryBuilder]
+        | None = None,
+        query: FileUploadQuery | None = None,
+    ) -> FileUploadQuery:
+        if filter_fn and query:
+            raise ValueError("Use either filter_fn OR query, not both")
+
+        if filter_fn:
+            builder = FileUploadQueryBuilder()
+            configured_builder = filter_fn(builder)
+            return configured_builder.build()
+
+        return query or FileUploadQuery()

notionary/file_upload/validation/factory.py

@@ -0,0 +1,66 @@
+from pathlib import Path
+
+from notionary.file_upload.validation.service import FileUploadValidationService
+from notionary.file_upload.validation.validators import (
+    FileExistsValidator,
+    FileExtensionValidator,
+    FileNameLengthValidator,
+    FileUploadLimitValidator,
+)
+
+
+def create_file_upload_validation_service(
+    file_path: Path,
+) -> FileUploadValidationService:
+    file_path = Path(file_path)
+    filename = file_path.name
+    file_size_bytes = file_path.stat().st_size
+
+    validation_service = FileUploadValidationService()
+
+    file_exists_validator = _create_file_exists_validator(file_path)
+    filename_length_validator = _create_filename_length_validator(filename)
+    extension_validator = _create_extension_validator(filename)
+    size_validator = _create_size_validator(filename, file_size_bytes)
+
+    validation_service.register(file_exists_validator)
+    validation_service.register(filename_length_validator)
+    validation_service.register(extension_validator)
+    validation_service.register(size_validator)
+
+    return validation_service
+
+
+def create_bytes_upload_validation_service(
+    filename: str,
+    file_size_bytes: int,
+) -> FileUploadValidationService:
+    validation_service = FileUploadValidationService()
+
+    filename_length_validator = _create_filename_length_validator(filename)
+    extension_validator = _create_extension_validator(filename)
+    size_validator = _create_size_validator(filename, file_size_bytes)
+
+    validation_service.register(filename_length_validator)
+    validation_service.register(extension_validator)
+    validation_service.register(size_validator)
+
+    return validation_service
+
+
+def _create_file_exists_validator(file_path: Path) -> FileExistsValidator:
+    return FileExistsValidator(file_path=file_path)
+
+
+def _create_filename_length_validator(filename: str) -> FileNameLengthValidator:
+    return FileNameLengthValidator(filename=filename)
+
+
+def _create_extension_validator(filename: str) -> FileExtensionValidator:
+    return FileExtensionValidator(filename=filename)
+
+
+def _create_size_validator(
+    filename: str, file_size_bytes: int
+) -> FileUploadLimitValidator:
+    return FileUploadLimitValidator(filename=filename, file_size_bytes=file_size_bytes)

notionary/file_upload/validation/impl/file_name_length.py

@@ -0,0 +1,25 @@
+from typing import override
+
+from notionary.exceptions.file_upload import FilenameTooLongError
+from notionary.file_upload.config.config import FileUploadConfig
+from notionary.file_upload.validation.port import FileUploadValidator
+
+
+class FileNameLengthValidator(FileUploadValidator):
+    def __init__(
+        self, filename: str, file_upload_config: FileUploadConfig | None = None
+    ) -> None:
+        self._filename = filename
+
+        file_upload_config = file_upload_config or FileUploadConfig()
+        self._max_filename_bytes = file_upload_config.MAX_FILENAME_BYTES
+
+    @override
+    async def validate(self) -> None:
+        filename_bytes = len(self._filename.encode("utf-8"))
+        if filename_bytes > self._max_filename_bytes:
+            raise FilenameTooLongError(
+                filename=self._filename,
+                filename_bytes=filename_bytes,
+                max_filename_bytes=self._max_filename_bytes,
+            )