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

notionary/file_upload/client.py

@@ -1,11 +1,11 @@
+import traceback
 from io import BytesIO
 from pathlib import Path
-from typing import BinaryIO, Optional
+from typing import BinaryIO
 
 import aiofiles
 import httpx
 
-from notionary.base_notion_client import BaseNotionClient
 from notionary.file_upload.models import (
     FileUploadCompleteRequest,
     FileUploadCreateRequest,
@@ -13,21 +13,22 @@ from notionary.file_upload.models import (
     FileUploadResponse,
     UploadMode,
 )
+from notionary.http.client import NotionHttpClient
 
 
-class NotionFileUploadClient(BaseNotionClient):
+class FileUploadHttpClient(NotionHttpClient):
     """
     Client for Notion file upload operations.
-    Inherits base HTTP functionality from BaseNotionClient.
+    Inherits base HTTP functionality from NotionHttpClient.
     """
 
     async def create_file_upload(
         self,
         filename: str,
-        content_type: Optional[str] = None,
-        content_length: Optional[int] = None,
+        content_type: str | None = None,
+        content_length: int | None = None,
         mode: UploadMode = UploadMode.SINGLE_PART,
-    ) -> Optional[FileUploadResponse]:
+    ) -> FileUploadResponse | None:
         """
         Create a new file upload.
 
@@ -61,8 +62,8 @@ class NotionFileUploadClient(BaseNotionClient):
         self,
         file_upload_id: str,
         file_content: BinaryIO,
-        filename: Optional[str] = None,
-        part_number: Optional[int] = None,
+        filename: str | None = None,
+        part_number: int | None = None,
     ) -> bool:
         """
         Send file content to Notion.
@@ -76,8 +77,6 @@ class NotionFileUploadClient(BaseNotionClient):
         Returns:
             True if successful, False otherwise
         """
-        await self.ensure_initialized()
-
         if not self.client:
             self.logger.error("HTTP client not initialized")
             return False
@@ -110,9 +109,7 @@ class NotionFileUploadClient(BaseNotionClient):
                 # Explicitly do NOT set Content-Type - let httpx handle multipart
             }
 
-            self.logger.debug(
-                "Sending file upload to %s with filename %s", url, filename
-            )
+            self.logger.debug("Sending file upload to %s with filename %s", url, filename)
 
             # Use a temporary client for the multipart upload
             async with httpx.AsyncClient(timeout=self.timeout) as upload_client:
@@ -130,7 +127,7 @@ class NotionFileUploadClient(BaseNotionClient):
         except httpx.HTTPStatusError as e:
             try:
                 error_text = e.response.text
-            except:
+            except Exception:
                 error_text = "Unable to read error response"
             error_msg = f"HTTP {e.response.status_code}: {error_text}"
             self.logger.error("Send file upload failed (%s): %s", url, error_msg)
@@ -142,14 +139,11 @@ class NotionFileUploadClient(BaseNotionClient):
 
         except Exception as e:
             self.logger.error("Unexpected error in send_file_upload: %s", str(e))
-            import traceback
 
             self.logger.debug("Full traceback: %s", traceback.format_exc())
             return False
 
-    async def complete_file_upload(
-        self, file_upload_id: str
-    ) -> Optional[FileUploadResponse]:
+    async def complete_file_upload(self, file_upload_id: str) -> FileUploadResponse | None:
         """
         Complete a multi-part file upload.
 
@@ -161,9 +155,7 @@ class NotionFileUploadClient(BaseNotionClient):
         """
         request_data = FileUploadCompleteRequest()
 
-        response = await self.post(
-            f"file_uploads/{file_upload_id}/complete", data=request_data.model_dump()
-        )
+        response = await self.post(f"file_uploads/{file_upload_id}/complete", data=request_data.model_dump())
         if response is None:
             return None
 
@@ -173,9 +165,7 @@ class NotionFileUploadClient(BaseNotionClient):
             self.logger.error("Failed to validate complete file upload response: %s", e)
             return None
 
-    async def retrieve_file_upload(
-        self, file_upload_id: str
-    ) -> Optional[FileUploadResponse]:
+    async def retrieve_file_upload(self, file_upload_id: str) -> FileUploadResponse | None:
         """
         Retrieve details of a file upload.
 
@@ -196,8 +186,8 @@ class NotionFileUploadClient(BaseNotionClient):
             return None
 
     async def list_file_uploads(
-        self, page_size: int = 100, start_cursor: Optional[str] = None
-    ) -> Optional[FileUploadListResponse]:
+        self, page_size: int = 100, start_cursor: str | None = None
+    ) -> FileUploadListResponse | None:
         """
         List file uploads for the current bot integration.
 
@@ -222,9 +212,7 @@ class NotionFileUploadClient(BaseNotionClient):
             self.logger.error("Failed to validate list file uploads response: %s", e)
             return None
 
-    async def send_file_from_path(
-        self, file_upload_id: str, file_path: Path, part_number: Optional[int] = None
-    ) -> bool:
+    async def send_file_from_path(self, file_upload_id: str, file_path: Path, part_number: int | None = None) -> bool:
         """
         Convenience method to send file from file path.
 

notionary/file_upload/models.py

@@ -1,6 +1,5 @@
 from enum import Enum
-
-from typing import Literal, Optional
+from typing import Literal
 
 from pydantic import BaseModel
 
@@ -25,9 +24,9 @@ class FileUploadResponse(BaseModel):
     upload_url: str
     archived: bool
     status: str  # "pending", "uploaded", "failed", etc.
-    filename: Optional[str] = None
-    content_type: Optional[str] = None
-    content_length: Optional[int] = None
+    filename: str | None = None
+    content_type: str | None = None
+    content_length: int | None = None
     request_id: str
 
 
@@ -38,7 +37,7 @@ class FileUploadListResponse(BaseModel):
 
     object: Literal["list"]
     results: list[FileUploadResponse]
-    next_cursor: Optional[str] = None
+    next_cursor: str | None = None
     has_more: bool
     type: Literal["file_upload"]
     file_upload: dict = {}
@@ -51,8 +50,8 @@ class FileUploadCreateRequest(BaseModel):
     """
 
     filename: str
-    content_type: Optional[str] = None
-    content_length: Optional[int] = None
+    content_type: str | None = None
+    content_length: int | None = None
     mode: UploadMode = UploadMode.SINGLE_PART
 
     def model_dump(self, **kwargs):

notionary/file_upload/{notion_file_upload.py → service.py}

@@ -3,10 +3,9 @@ import mimetypes
 from datetime import datetime, timedelta
 from io import BytesIO
 from pathlib import Path
-from typing import Optional
 
 from notionary.file_upload.models import FileUploadResponse, UploadMode
-from notionary.util import LoggingMixin
+from notionary.utils.mixins.logging import LoggingMixin
 
 
 class NotionFileUpload(LoggingMixin):
@@ -20,15 +19,13 @@ class NotionFileUpload(LoggingMixin):
     MULTI_PART_CHUNK_SIZE = 10 * 1024 * 1024  # 10MB per part
     MAX_FILENAME_BYTES = 900
 
-    def __init__(self, token: Optional[str] = None):
+    def __init__(self, token: str | None = None):
         """Initialize the file upload service."""
-        from notionary.file_upload import NotionFileUploadClient
+        from notionary.file_upload import FileUploadHttpClient
 
-        self.client = NotionFileUploadClient(token=token)
+        self.client = FileUploadHttpClient(token=token)
 
-    async def upload_file(
-        self, file_path: Path, filename: Optional[str] = None
-    ) -> Optional[FileUploadResponse]:
+    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.
 
@@ -62,8 +59,8 @@ class NotionFileUpload(LoggingMixin):
             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]:
+        self, file_content: bytes, filename: str, content_type: str | None = None
+    ) -> FileUploadResponse | None:
         """
         Upload file content from bytes.
 
@@ -92,15 +89,11 @@ class NotionFileUpload(LoggingMixin):
 
         # 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
-            )
+            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
-            )
+            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]:
+    async def get_upload_status(self, file_upload_id: str) -> str | None:
         """
         Get the current status of a file upload.
 
@@ -115,7 +108,7 @@ class NotionFileUpload(LoggingMixin):
 
     async def wait_for_upload_completion(
         self, file_upload_id: str, timeout_seconds: int = 300, poll_interval: int = 2
-    ) -> Optional[FileUploadResponse]:
+    ) -> FileUploadResponse | None:
         """
         Wait for a file upload to complete.
 
@@ -134,9 +127,7 @@ class NotionFileUpload(LoggingMixin):
             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
-                )
+                self.logger.error("Failed to retrieve upload info for %s", file_upload_id)
                 return None
 
             if upload_info.status == "uploaded":
@@ -168,9 +159,7 @@ class NotionFileUpload(LoggingMixin):
         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
-            )
+            response = await self.client.list_file_uploads(page_size=page_size, start_cursor=start_cursor)
 
             if not response or not response.results:
                 break
@@ -185,9 +174,7 @@ class NotionFileUpload(LoggingMixin):
 
         return uploads[:limit]
 
-    async def _upload_small_file(
-        self, file_path: Path, filename: str, file_size: int
-    ) -> Optional[FileUploadResponse]:
+    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))
 
@@ -204,22 +191,16 @@ class NotionFileUpload(LoggingMixin):
             return None
 
         # Send file content
-        success = await self.client.send_file_from_path(
-            file_upload_id=file_upload.id, file_path=file_path
-        )
+        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
-        )
+        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]:
+    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))
 
@@ -232,9 +213,7 @@ class NotionFileUpload(LoggingMixin):
         )
 
         if not file_upload:
-            self.logger.error(
-                "Failed to create multi-part file upload for %s", filename
-            )
+            self.logger.error("Failed to create multi-part file upload for %s", filename)
             return None
 
         # Upload file in parts
@@ -251,18 +230,16 @@ class NotionFileUpload(LoggingMixin):
             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
-        )
+        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],
+        content_type: str | None,
         file_size: int,
-    ) -> Optional[FileUploadResponse]:
+    ) -> FileUploadResponse | None:
         """Upload small file from bytes."""
         # Create file upload
         file_upload = await self.client.create_file_upload(
@@ -290,9 +267,9 @@ class NotionFileUpload(LoggingMixin):
         self,
         file_content: bytes,
         filename: str,
-        content_type: Optional[str],
+        content_type: str | None,
         file_size: int,
-    ) -> Optional[FileUploadResponse]:
+    ) -> FileUploadResponse | None:
         """Upload large file from bytes using multi-part."""
         # Create file upload
         file_upload = await self.client.create_file_upload(
@@ -314,14 +291,10 @@ class NotionFileUpload(LoggingMixin):
         # 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:
+    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
+        total_parts = (file_size + self.MULTI_PART_CHUNK_SIZE - 1) // self.MULTI_PART_CHUNK_SIZE
 
         try:
             import aiofiles
@@ -340,9 +313,7 @@ class NotionFileUpload(LoggingMixin):
                     )
 
                     if not success:
-                        self.logger.error(
-                            "Failed to upload part %d/%d", part_number, total_parts
-                        )
+                        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)
@@ -355,14 +326,10 @@ class NotionFileUpload(LoggingMixin):
             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:
+    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
+        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]
@@ -374,9 +341,7 @@ class NotionFileUpload(LoggingMixin):
             )
 
             if not success:
-                self.logger.error(
-                    "Failed to upload part %d/%d", part_number, total_parts
-                )
+                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)

notionary/http/client.py

@@ -0,0 +1,205 @@
+import asyncio
+import os
+from typing import Any
+
+import httpx
+from dotenv import load_dotenv
+
+from notionary.exceptions.api import (
+    NotionApiError,
+    NotionAuthenticationError,
+    NotionConnectionError,
+    NotionPermissionError,
+    NotionRateLimitError,
+    NotionResourceNotFoundError,
+    NotionServerError,
+    NotionValidationError,
+)
+from notionary.http.models import HttpMethod
+from notionary.utils.mixins.logging import LoggingMixin
+
+load_dotenv()
+
+
+class NotionHttpClient(LoggingMixin):
+    BASE_URL = "https://api.notion.com/v1"
+    NOTION_VERSION = "2025-09-03"
+
+    def __init__(self, timeout: int = 30):
+        self.token = self._find_token()
+        if not self.token:
+            raise ValueError(
+                "No Notion API token found in environment variables. Please set one of these environment variables: "
+                "NOTION_SECRET, NOTION_INTEGRATION_KEY, or NOTION_TOKEN"
+            )
+
+        self.headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json",
+            "Notion-Version": self.NOTION_VERSION,
+        }
+
+        self.client: httpx.AsyncClient | None = None
+        self.timeout = timeout
+        self._is_initialized = False
+
+    def __del__(self):
+        """Auto-cleanup when client is destroyed."""
+        if not hasattr(self, "client") or not self.client:
+            return
+
+        try:
+            loop = asyncio.get_event_loop()
+            if not loop.is_running():
+                self.logger.warning("Event loop not running, could not auto-close NotionHttpClient")
+                return
+
+            loop.create_task(self.close())
+            self.logger.debug("Created cleanup task for NotionHttpClient")
+        except RuntimeError:
+            self.logger.warning("No event loop available for auto-closing NotionHttpClient")
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self._ensure_initialized()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()
+
+    async def close(self) -> None:
+        """
+        Closes the HTTP client and releases resources.
+        """
+        if not hasattr(self, "client") or not self.client:
+            return
+
+        await self.client.aclose()
+        self.client = None
+        self._is_initialized = False
+        self.logger.debug("NotionHttpClient closed")
+
+    async def get(self, endpoint: str, params: dict[str, Any] | None = None) -> dict[str, Any] | None:
+        return await self.make_request(HttpMethod.GET, endpoint, params=params)
+
+    async def post(self, endpoint: str, data: dict[str, Any] | None = None) -> dict[str, Any] | None:
+        return await self.make_request(HttpMethod.POST, endpoint, data)
+
+    async def patch(self, endpoint: str, data: dict[str, Any] | None = None) -> dict[str, Any] | None:
+        return await self.make_request(HttpMethod.PATCH, endpoint, data)
+
+    async def delete(self, endpoint: str) -> dict[str, Any] | None:
+        return await self.make_request(HttpMethod.DELETE, endpoint)
+
+    async def make_request(
+        self,
+        method: HttpMethod,
+        endpoint: str,
+        data: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any] | None:
+        """
+        Executes an HTTP request and returns the data or None on error.
+
+        Args:
+            method: HTTP method to use
+            endpoint: API endpoint
+            data: Request body data (for POST/PATCH)
+            params: Query parameters (for GET requests)
+        """
+        await self._ensure_initialized()
+
+        url = f"{self.BASE_URL}/{endpoint.lstrip('/')}"
+        try:
+            self.logger.debug("Sending %s request to %s", method.value.upper(), url)
+
+            request_kwargs = {}
+
+            # Add query parameters for GET requests
+            if params:
+                request_kwargs["params"] = params
+
+            if method.value in [HttpMethod.POST.value, HttpMethod.PATCH.value] and data is not None:
+                request_kwargs["json"] = data
+
+            response: httpx.Response = await getattr(self.client, method.value)(url, **request_kwargs)
+
+            response.raise_for_status()
+            result_data = response.json()
+            self.logger.debug("Request successful: %s", url)
+            return result_data
+
+        except httpx.HTTPStatusError as e:
+            self._handle_http_status_error(e)
+        except httpx.RequestError as e:
+            raise NotionConnectionError(
+                f"Failed to connect to Notion API: {e!s}. Please check your internet connection and try again."
+            ) from e
+
+    def _handle_http_status_error(self, e: httpx.HTTPStatusError) -> None:
+        status_code = e.response.status_code
+        response_text = e.response.text
+
+        # Map HTTP status codes to specific business exceptions
+        if status_code == 401:
+            raise NotionAuthenticationError(
+                "Invalid or missing API key. Please check your Notion integration token.",
+                status_code=status_code,
+                response_text=response_text,
+            )
+        if status_code == 403:
+            raise NotionPermissionError(
+                "Insufficient permissions. Please check your integration settings at "
+                "https://www.notion.so/profile/integrations and ensure the integration "
+                "has access to the required pages/databases.",
+                status_code=status_code,
+                response_text=response_text,
+            )
+        if status_code == 404:
+            raise NotionResourceNotFoundError(
+                "The requested resource was not found. Please verify the page/database ID.",
+                status_code=status_code,
+                response_text=response_text,
+            )
+        if status_code == 400:
+            raise NotionValidationError(
+                f"Invalid request data. Please check your input parameters: {response_text}",
+                status_code=status_code,
+                response_text=response_text,
+            )
+        if status_code == 429:
+            raise NotionRateLimitError(
+                "Rate limit exceeded. Please wait before making more requests.",
+                status_code=status_code,
+                response_text=response_text,
+            )
+        if 500 <= status_code < 600:
+            raise NotionServerError(
+                "Notion API server error. Please try again later.",
+                status_code=status_code,
+                response_text=response_text,
+            )
+
+        raise NotionApiError(
+            f"API request failed with status {status_code}: {response_text}",
+            status_code=status_code,
+            response_text=response_text,
+        )
+
+    def _find_token(self) -> str | None:
+        token = next(
+            (os.getenv(var) for var in ("NOTION_SECRET", "NOTION_INTEGRATION_KEY", "NOTION_TOKEN") if os.getenv(var)),
+            None,
+        )
+        if token:
+            self.logger.debug("Found token in environment variable.")
+            return token
+        self.logger.warning("No Notion API token found in environment variables")
+        return None
+
+    async def _ensure_initialized(self) -> None:
+        if not self._is_initialized or not self.client:
+            self.client = httpx.AsyncClient(headers=self.headers, timeout=self.timeout)
+            self._is_initialized = True
+            self.logger.debug("NotionHttpClient initialized")

notionary/http/models.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Any
+
+
+class HttpMethod(StrEnum):
+    GET = "get"
+    POST = "post"
+    PATCH = "patch"
+    DELETE = "delete"
+
+
+@dataclass
+class HttpRequest:
+    method: HttpMethod
+    endpoint: str
+    data: dict[str, Any] | None = None
+    params: dict[str, Any] | None = None
+    timestamp: float = field(default_factory=time.time)
+    cached_response: HttpResponse | None = None
+
+    @property
+    def cache_key(self) -> str:
+        key_parts = [self.method.value, self.endpoint]
+
+        if self.params:
+            sorted_params = sorted(self.params.items())
+            key_parts.extend(f"{k}={v}" for k, v in sorted_params)
+
+        return "|".join(key_parts)
+
+    def __repr__(self) -> str:
+        return f"HttpRequest(method={self.method.value}, endpoint={self.endpoint})"
+
+
+@dataclass
+class HttpResponse:
+    data: dict[str, Any] | None
+    status_code: int = 200
+    headers: dict[str, str] = field(default_factory=dict)
+    timestamp: float = field(default_factory=time.time)
+    from_cache: bool = False
+    error: Exception | None = None
+
+    def __repr__(self) -> str:
+        return f"HttpResponse(status_code={self.status_code}, from_cache={self.from_cache})"

notionary/page/blocks/client.py

@@ -0,0 +1 @@
+# PageBlockClient