notionary 0.2.15__py3-none-any.whl → 0.2.17__py3-none-any.whl

notionary/database/{notion_database_provider.py → database_provider.py}

@@ -2,10 +2,10 @@ from __future__ import annotations
 
 from typing import Dict, Optional, TYPE_CHECKING
 from notionary.database.client import NotionDatabaseClient
-from notionary.database.database_exceptions import DatabaseNotFoundException
+from notionary.database.exceptions import DatabaseNotFoundException
 from notionary.models.notion_database_response import NotionDatabaseResponse
-from notionary.util import LoggingMixin, FuzzyMatcher, format_uuid
-from notionary.util.singleton_metaclass import SingletonMetaClass
+from notionary.util import LoggingMixin, format_uuid, SingletonMetaClass
+from notionary.util.fuzzy import find_best_match
 
 if TYPE_CHECKING:
     from notionary import NotionDatabase
@@ -57,18 +57,14 @@ class NotionDatabaseProvider(LoggingMixin, metaclass=SingletonMetaClass):
 
         id_cache_key = self._create_id_cache_key(database.id)
         if not force_refresh and id_cache_key in self._database_cache:
-            self.logger.debug(
-                f"Found existing cached database by ID: {database.id}"
-            )
+            self.logger.debug(f"Found existing cached database by ID: {database.id}")
             existing_database = self._database_cache[id_cache_key]
 
             self._database_cache[name_cache_key] = existing_database
             return existing_database
 
         self._cache_database(database, token, database_name)
-        self.logger.debug(
-            f"Cached database: {database.title} (ID: {database.id})"
-        )
+        self.logger.debug(f"Cached database: {database.title} (ID: {database.id})")
 
         return database
 
@@ -129,7 +125,7 @@ class NotionDatabaseProvider(LoggingMixin, metaclass=SingletonMetaClass):
                 self.logger.warning("No databases found for name: %s", database_name)
                 raise DatabaseNotFoundException(database_name)
 
-            best_match = FuzzyMatcher.find_best_match(
+            best_match = find_best_match(
                 query=database_name,
                 items=search_result.results,
                 text_extractor=lambda db: self._extract_title(db),

notionary/database/notion_database.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
+import asyncio
 import random
-from typing import Any, AsyncGenerator, Dict, List, Optional
+from typing import Any, AsyncGenerator, Dict, Optional
 
 from notionary.database.client import NotionDatabaseClient
 from notionary.models.notion_database_response import (
@@ -8,11 +9,16 @@ from notionary.models.notion_database_response import (
     NotionPageResponse,
     NotionQueryDatabaseResponse,
 )
-from notionary.page.notion_page import NotionPage
+from notionary import NotionPage
 
-from notionary.database.notion_database_provider import NotionDatabaseProvider
+from notionary.database.database_provider import NotionDatabaseProvider
 
-from notionary.database.filter_builder import FilterBuilder
+from notionary.database.database_filter_builder import DatabaseFilterBuilder
+from notionary.telemetry import (
+    ProductTelemetry,
+    DatabaseFactoryUsedEvent,
+    QueryOperationEvent,
+)
 from notionary.util import factory_only, LoggingMixin
 
 
@@ -23,6 +29,8 @@ class NotionDatabase(LoggingMixin):
     for further page operations.
     """
 
+    telemetry = ProductTelemetry()
+
     @factory_only("from_database_id", "from_database_name")
     def __init__(
         self,
@@ -52,6 +60,10 @@ class NotionDatabase(LoggingMixin):
         Create a NotionDatabase from a database ID using NotionDatabaseProvider.
         """
         provider = cls.get_database_provider()
+        cls.telemetry.capture(
+            DatabaseFactoryUsedEvent(factory_method="from_database_id")
+        )
+
         return await provider.get_database_by_id(id, token)
 
     @classmethod
@@ -65,6 +77,9 @@ class NotionDatabase(LoggingMixin):
         Create a NotionDatabase by finding a database with fuzzy matching on the title using NotionDatabaseProvider.
         """
         provider = cls.get_database_provider()
+        cls.telemetry.capture(
+            DatabaseFactoryUsedEvent(factory_method="from_database_name")
+        )
         return await provider.get_database_by_name(database_name, token, min_similarity)
 
     @property
@@ -129,9 +144,7 @@ class NotionDatabase(LoggingMixin):
 
             self._title = result.title[0].plain_text
             self.logger.info(f"Successfully updated database title to: {new_title}")
-            self.database_provider.invalidate_database_cache(
-                database_id=self.id
-            )
+            self.database_provider.invalidate_database_cache(database_id=self.id)
             return True
 
         except Exception as e:
@@ -149,9 +162,7 @@ class NotionDatabase(LoggingMixin):
 
             self._emoji_icon = result.icon.emoji if result.icon else None
             self.logger.info(f"Successfully updated database emoji to: {new_emoji}")
-            self.database_provider.invalidate_database_cache(
-                database_id=self.id
-            )
+            self.database_provider.invalidate_database_cache(database_id=self.id)
             return True
 
         except Exception as e:
@@ -168,9 +179,7 @@ class NotionDatabase(LoggingMixin):
             )
 
             if result.cover and result.cover.external:
-                self.database_provider.invalidate_database_cache(
-                    database_id=self.id
-                )
+                self.database_provider.invalidate_database_cache(database_id=self.id)
                 return result.cover.external.url
             return None
 
@@ -197,9 +206,7 @@ class NotionDatabase(LoggingMixin):
             )
 
             if result.icon and result.icon.external:
-                self.database_provider.invalidate_database_cache(
-                    database_id=self.id
-                )
+                self.database_provider.invalidate_database_cache(database_id=self.id)
                 return result.icon.external.url
             return None
 
@@ -207,7 +214,7 @@ class NotionDatabase(LoggingMixin):
             self.logger.error(f"Error updating database external icon: {str(e)}")
             return None
 
-    async def get_options_by_property_name(self, property_name: str) -> List[str]:
+    async def get_options_by_property_name(self, property_name: str) -> list[str]:
         """
         Retrieve all option names for a select, multi_select, status, or relation property.
 
@@ -238,7 +245,7 @@ class NotionDatabase(LoggingMixin):
         property_schema = self.properties.get(property_name)
         return property_schema.get("type") if property_schema else None
 
-    async def query_database_by_title(self, page_title: str) -> List[NotionPage]:
+    async def query_database_by_title(self, page_title: str) -> list[NotionPage]:
         """
         Query the database for pages with a specific title.
         """
@@ -248,22 +255,28 @@ class NotionDatabase(LoggingMixin):
             )
         )
 
-        page_results: List[NotionPage] = []
+        page_results: list[NotionPage] = []
 
         for page in search_results.results:
-            page = NotionPage.from_page_id(page_id=page.id, token=self.client.token)
+            page = await NotionPage.from_page_id(
+                page_id=page.id, token=self.client.token
+            )
             page_results.append(page)
 
+        self.telemetry.capture(
+            QueryOperationEvent(query_type="query_database_by_title")
+        )
+
         return page_results
 
     async def iter_pages_updated_within(
         self, hours: int = 24, page_size: int = 100
     ) -> AsyncGenerator[NotionPage, None]:
         """
-        Iterate through pages edited in the last N hours using FilterBuilder.
+        Iterate through pages edited in the last N hours using DatabaseFilterBuilder.
         """
 
-        filter_builder = FilterBuilder()
+        filter_builder = DatabaseFilterBuilder()
         filter_builder.with_updated_last_n_hours(hours).with_page_size(page_size)
         filter_conditions = filter_builder.build()
 
@@ -272,13 +285,39 @@ class NotionDatabase(LoggingMixin):
         ):
             yield page
 
-    async def get_all_pages(self) -> List[NotionPage]:
+    async def get_all_pages(self) -> list[NotionPage]:
         """
         Get all pages in the database (use with caution for large databases).
+        Uses asyncio.gather to parallelize NotionPage creation per API page.
         """
-        pages = []
-        async for page in self._iter_pages():
-            pages.append(page)
+        pages: list[NotionPage] = []
+        start_cursor: Optional[str] = None
+        has_more = True
+        body: Dict[str, Any] = {"page_size": 100}
+
+        while has_more:
+            current_body = body.copy()
+            if start_cursor:
+                current_body["start_cursor"] = start_cursor
+
+            result = await self.client.query_database(
+                database_id=self.id, query_data=current_body
+            )
+
+            if not result or not result.results:
+                break
+
+            # Parallelize NotionPage creation for this batch
+            page_tasks = [
+                NotionPage.from_page_id(page_id=page.id, token=self.client.token)
+                for page in result.results
+            ]
+            batch_pages = await asyncio.gather(*page_tasks)
+            pages.extend(batch_pages)
+
+            has_more = result.has_more
+            start_cursor = result.next_cursor if has_more else None
+
         return pages
 
     async def get_last_edited_time(self) -> Optional[str]:
@@ -289,7 +328,7 @@ class NotionDatabase(LoggingMixin):
             ISO 8601 timestamp string of the last database edit, or None if request fails.
         """
         try:
-            db = await self.client.get_database(self.database_id)
+            db = await self.client.get_database(self.id)
 
             return db.last_edited_time
 
@@ -301,12 +340,12 @@ class NotionDatabase(LoggingMixin):
             )
             return None
 
-    def create_filter(self) -> FilterBuilder:
+    def create_filter(self) -> DatabaseFilterBuilder:
         """Create a new filter builder for this database."""
-        return FilterBuilder()
+        return DatabaseFilterBuilder()
 
     async def iter_pages_with_filter(
-        self, filter_builder: FilterBuilder, page_size: int = 100
+        self, filter_builder: DatabaseFilterBuilder, page_size: int = 100
     ):
         """Iterate pages using a filter builder."""
         filter_config = filter_builder.build()
@@ -352,7 +391,9 @@ class NotionDatabase(LoggingMixin):
                 return
 
             for page in result.results:
-                yield await NotionPage.from_page_id(page_id=page.id, token=self.client.token)
+                yield await NotionPage.from_page_id(
+                    page_id=page.id, token=self.client.token
+                )
 
             has_more = result.has_more
             start_cursor = result.next_cursor if has_more else None
@@ -426,7 +467,7 @@ class NotionDatabase(LoggingMixin):
         except (KeyError, TypeError, AttributeError):
             return None
 
-    async def _get_relation_options(self, property_name: str) -> List[Dict[str, Any]]:
+    async def _get_relation_options(self, property_name: str) -> list[Dict[str, Any]]:
         """
         Retrieve the titles of all pages related to a relation property.
 

notionary/file_upload/__init__.py

@@ -0,0 +1,7 @@
+from .client import NotionFileUploadClient
+from .notion_file_upload import NotionFileUpload
+
+__all__ = [
+    "NotionFileUploadClient",
+    "NotionFileUpload",
+]

notionary/file_upload/client.py

@@ -0,0 +1,254 @@
+from typing import Optional, BinaryIO
+from io import BytesIO
+from pathlib import Path
+import httpx
+
+import aiofiles
+
+from notionary.base_notion_client import BaseNotionClient
+from notionary.file_upload.models import (
+    FileUploadResponse,
+    FileUploadListResponse,
+    FileUploadCreateRequest,
+    FileUploadCompleteRequest,
+)
+from notionary.util import singleton
+
+
+@singleton
+class NotionFileUploadClient(BaseNotionClient):
+    """
+    Client for Notion file upload operations.
+    Inherits base HTTP functionality from BaseNotionClient.
+    """
+
+    async def create_file_upload(
+        self,
+        filename: str,
+        content_type: Optional[str] = None,
+        content_length: Optional[int] = None,
+        mode: str = "single_part",
+    ) -> Optional[FileUploadResponse]:
+        """
+        Create a new file upload.
+
+        Args:
+            filename: Name of the file (max 900 bytes)
+            content_type: MIME type of the file
+            content_length: Size of the file in bytes
+            mode: Upload mode ("single_part" or "multi_part")
+
+        Returns:
+            FileUploadResponse or None if failed
+        """
+        request_data = FileUploadCreateRequest(
+            filename=filename,
+            content_type=content_type,
+            content_length=content_length,
+            mode=mode,
+        )
+
+        response = await self.post("file_uploads", data=request_data.model_dump())
+        if response is None:
+            return None
+
+        try:
+            return FileUploadResponse.model_validate(response)
+        except Exception as e:
+            self.logger.error("Failed to validate file upload response: %s", e)
+            return None
+
+    async def send_file_upload(
+        self,
+        file_upload_id: str,
+        file_content: BinaryIO,
+        filename: Optional[str] = None,
+        part_number: Optional[int] = None,
+    ) -> bool:
+        """
+        Send file content to Notion.
+
+        Args:
+            file_upload_id: ID of the file upload
+            file_content: Binary file content
+            filename: Optional filename for the form data
+            part_number: Part number for multi-part uploads
+
+        Returns:
+            True if successful, False otherwise
+        """
+        await self.ensure_initialized()
+
+        if not self.client:
+            self.logger.error("HTTP client not initialized")
+            return False
+
+        url = f"{self.BASE_URL}/file_uploads/{file_upload_id}/send"
+
+        try:
+            # Read all content from BinaryIO into bytes
+            if hasattr(file_content, "read"):
+                file_bytes = file_content.read()
+                # Reset position if possible (for BytesIO objects)
+                if hasattr(file_content, "seek"):
+                    file_content.seek(0)
+            else:
+                file_bytes = file_content
+
+            # Prepare files dict for multipart upload
+            files = {"file": (filename or "file", file_bytes)}
+
+            # Prepare form data (only for multi-part uploads)
+            data = {}
+            if part_number is not None:
+                data["part_number"] = str(part_number)
+
+            # Create a new client instance specifically for this upload
+            # This avoids issues with the base client's default JSON headers
+            upload_headers = {
+                "Authorization": f"Bearer {self.token}",
+                "Notion-Version": self.NOTION_VERSION,
+                # Explicitly do NOT set Content-Type - let httpx handle multipart
+            }
+
+            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:
+                response = await upload_client.post(
+                    url,
+                    files=files,
+                    data=data if data else None,
+                    headers=upload_headers,
+                )
+
+                response.raise_for_status()
+                self.logger.debug("File upload sent successfully: %s", file_upload_id)
+                return True
+
+        except httpx.HTTPStatusError as e:
+            try:
+                error_text = e.response.text
+            except:
+                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)
+            return False
+
+        except httpx.RequestError as e:
+            self.logger.error("Request error sending file upload (%s): %s", url, str(e))
+            return False
+
+        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]:
+        """
+        Complete a multi-part file upload.
+
+        Args:
+            file_upload_id: ID of the file upload
+
+        Returns:
+            FileUploadResponse or None if failed
+        """
+        request_data = FileUploadCompleteRequest()
+
+        response = await self.post(
+            f"file_uploads/{file_upload_id}/complete", data=request_data.model_dump()
+        )
+        if response is None:
+            return None
+
+        try:
+            return FileUploadResponse.model_validate(response)
+        except Exception as e:
+            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]:
+        """
+        Retrieve details of a file upload.
+
+        Args:
+            file_upload_id: ID of the file upload
+
+        Returns:
+            FileUploadResponse or None if failed
+        """
+        response = await self.get(f"file_uploads/{file_upload_id}")
+        if response is None:
+            return None
+
+        try:
+            return FileUploadResponse.model_validate(response)
+        except Exception as e:
+            self.logger.error("Failed to validate retrieve file upload response: %s", e)
+            return None
+
+    async def list_file_uploads(
+        self, page_size: int = 100, start_cursor: Optional[str] = None
+    ) -> Optional[FileUploadListResponse]:
+        """
+        List file uploads for the current bot integration.
+
+        Args:
+            page_size: Number of uploads per page (max 100)
+            start_cursor: Cursor for pagination
+
+        Returns:
+            FileUploadListResponse or None if failed
+        """
+        params = {"page_size": min(page_size, 100)}
+        if start_cursor:
+            params["start_cursor"] = start_cursor
+
+        response = await self.get("file_uploads", params=params)
+        if response is None:
+            return None
+
+        try:
+            return FileUploadListResponse.model_validate(response)
+        except Exception as e:
+            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:
+        """
+        Convenience method to send file from file path.
+
+        Args:
+            file_upload_id: ID of the file upload
+            file_path: Path to the file
+            part_number: Part number for multi-part uploads
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Read file content into memory first using aiofiles
+            async with aiofiles.open(file_path, "rb") as f:
+                file_content = await f.read()
+
+            # Use BytesIO for the upload
+            return await self.send_file_upload(
+                file_upload_id=file_upload_id,
+                file_content=BytesIO(file_content),
+                filename=file_path.name,
+                part_number=part_number,
+            )
+        except Exception as e:
+            self.logger.error("Failed to send file from path %s: %s", file_path, e)
+            return False

notionary/file_upload/models.py

@@ -0,0 +1,60 @@
+from typing import Literal, Optional, List
+from pydantic import BaseModel
+
+
+class FileUploadResponse(BaseModel):
+    """
+    Represents a Notion file upload object as returned by the File Upload API.
+    """
+
+    object: Literal["file_upload"]
+    id: str
+    created_time: str
+    last_edited_time: str
+    expiry_time: str
+    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
+    request_id: str
+
+
+class FileUploadListResponse(BaseModel):
+    """
+    Response model for listing file uploads from /v1/file_uploads endpoint.
+    """
+
+    object: Literal["list"]
+    results: List[FileUploadResponse]
+    next_cursor: Optional[str] = None
+    has_more: bool
+    type: Literal["file_upload"]
+    file_upload: dict = {}
+    request_id: str
+
+
+class FileUploadCreateRequest(BaseModel):
+    """
+    Request model for creating a file upload.
+    """
+
+    filename: str
+    content_type: Optional[str] = None
+    content_length: Optional[int] = None
+    mode: Literal["single_part", "multi_part"] = "single_part"
+
+    def model_dump(self, **kwargs):
+        """Override to exclude None values"""
+        data = super().model_dump(**kwargs)
+        return {k: v for k, v in data.items() if v is not None}
+
+
+class FileUploadCompleteRequest(BaseModel):
+    """
+    Request model for completing a multi-part file upload.
+    """
+
+    # Usually empty for complete requests, but keeping for future extensibility
+    pass