notionary 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

notionary/core/database/notion_database_manager.py

@@ -1,244 +1,83 @@
-from typing import Any, AsyncGenerator, Dict, List, Optional, Union
+from typing import Any, AsyncGenerator, Dict, List, Optional
 
-from notionary.core.database.database_info_service import DatabaseInfoService
-from notionary.core.database.database_query_service import DatabaseQueryService
-from notionary.core.database.database_schema_service import DatabaseSchemaService
-from notionary.core.database.models.page_result import PageResult
-from notionary.core.database.page_service import DatabasePageService
 from notionary.core.notion_client import NotionClient
-from notionary.core.database.notion_database_schema import NotionDatabaseSchema
-from notionary.core.database.notion_database_writer import DatabaseWritter
 from notionary.core.page.notion_page_manager import NotionPageManager
-from notionary.exceptions.database_exceptions import (
-    DatabaseInitializationError,
-    PropertyError,
-)
 from notionary.util.logging_mixin import LoggingMixin
-from notionary.util.uuid_utils import format_uuid
+from notionary.util.page_id_utils import format_uuid
 
 
 class NotionDatabaseManager(LoggingMixin):
     """
-    High-level facade for working with Notion databases.
-    Provides simplified operations for creating, reading, updating and deleting pages.
-
-    Note:
-        It is recommended to create instances of this class using the NotionDatabaseFactory
-        instead of directly calling the constructor.
+    Minimal manager for Notion databases.
+    Focused exclusively on creating basic pages and retrieving page managers 
+    for further page operations.
     """
 
     def __init__(self, database_id: str, token: Optional[str] = None):
         """
-        Initialize the database facade with a database ID.
-
-        Note:
-            It's recommended to use NotionDatabaseFactory to create instances of this class
-            rather than using this constructor directly.
+        Initialize the minimal database manager.
 
         Args:
-            database_id: The ID of the Notion database
-            token: Optional Notion API token (uses environment variable if not provided)
+            database_id: ID of the Notion database
+            token: Optional Notion API token
         """
         self.database_id = format_uuid(database_id) or database_id
         self._client = NotionClient(token=token)
-        self._schema = NotionDatabaseSchema(self.database_id, self._client)
-        self._writer = DatabaseWritter(self._client, self._schema)
-        self._initialized = False
-
-        self._info_service = DatabaseInfoService(self._client, self.database_id)
-        self._page_service = DatabasePageService(
-            self._client, self._schema, self._writer
-        )
-        self._query_service = DatabaseQueryService(self._schema)
-        self._schema_service = DatabaseSchemaService(self._schema)
 
-    @property
-    def title(self) -> Optional[str]:
-        """Get the database title."""
-        return self._info_service.title
-
-    async def initialize(self) -> bool:
-        """
-        Initialize the database facade by loading the schema.
-
-        This method needs to be called after creating a new instance via the constructor.
-        When using NotionDatabaseFactory, this is called automatically.
-        """
-        try:
-            success = await self._schema.load()
-            if not success:
-                self.logger.error(
-                    "Failed to load schema for database %s", self.database_id
-                )
-                return False
-
-            await self._info_service.load_title()
-            self.logger.debug("Loaded database title: %s", self.title)
-
-            self._initialized = True
-            return True
-        except Exception as e:
-            self.logger.error("Error initializing database: %s", str(e))
-            return False
-
-    async def _ensure_initialized(self) -> None:
-        """
-        Ensure the database manager is initialized before use.
-
-        Raises:
-            DatabaseInitializationError: If the database isn't initialized
-        """
-        if not self._initialized:
-            raise DatabaseInitializationError(
-                self.database_id,
-                "Database manager not initialized. Call initialize() first.",
-            )
 
-    async def get_database_name(self) -> Optional[str]:
+    async def create_blank_page(self) -> Optional[str]:
         """
-        Get the name of the current database.
-
+        Create a new blank page in the database with minimal properties.
+        
         Returns:
-            The database name or None if it couldn't be retrieved
+            Optional[str]: The ID of the created page, or None if creation failed
         """
-        await self._ensure_initialized()
-
-        if self.title:
-            return self.title
-
         try:
-            return await self._info_service.load_title()
-        except PropertyError as e:
-            self.logger.error("Error getting database name: %s", str(e))
-            return None
-
-    async def get_property_types(self) -> Dict[str, str]:
-        """
-        Get all property types for the database.
-
-        Returns:
-            Dictionary mapping property names to their types
-        """
-        await self._ensure_initialized()
-        return await self._schema_service.get_property_types()
-
-    async def get_select_options(self, property_name: str) -> List[Dict[str, str]]:
-        """
-        Get options for a select, multi-select, or status property.
-
-        Args:
-            property_name: Name of the property
-
-        Returns:
-            List of select options with name, id, and color (if available)
-        """
-        await self._ensure_initialized()
-        return await self._schema_service.get_select_options(property_name)
-
-    async def get_relation_options(
-        self, property_name: str, limit: int = 100
-    ) -> List[Dict[str, str]]:
-        """
-        Get available options for a relation property.
-
-        Args:
-            property_name: Name of the relation property
-            limit: Maximum number of options to retrieve
-
-        Returns:
-            List of relation options with id and title
-        """
-        await self._ensure_initialized()
-        return await self._schema_service.get_relation_options(property_name, limit)
-
-    async def create_page(
-        self,
-        properties: Dict[str, Any],
-        relations: Optional[Dict[str, Union[str, List[str]]]] = None,
-    ) -> PageResult:
-        """
-        Create a new page in the database.
-
-        Args:
-            properties: Dictionary of property names and values
-            relations: Optional dictionary of relation property names and titles
-
-        Returns:
-            Result object with success status and page information
-        """
-        await self._ensure_initialized()
-
-        result = await self._page_service.create_page(
-            self.database_id, properties, relations
-        )
-
-        if result["success"]:
-            self.logger.info(
-                "Created page %s in database %s",
-                result.get("page_id", ""),
-                self.database_id,
-            )
-        else:
-            self.logger.warning("Page creation failed: %s", result.get("message", ""))
-
-        return result
-
-    async def update_page(
-        self,
-        page_id: str,
-        properties: Optional[Dict[str, Any]] = None,
-        relations: Optional[Dict[str, Union[str, List[str]]]] = None,
-    ) -> PageResult:
-        """
-        Update an existing page.
-
-        Args:
-            page_id: The ID of the page to update
-            properties: Dictionary of property names and values to update
-            relations: Optional dictionary of relation property names and titles
-
-        Returns:
-            Result object with success status and message
-        """
-        await self._ensure_initialized()
-
-        self.logger.debug("Updating page %s", page_id)
-
-        result = await self._page_service.update_page(page_id, properties, relations)
-
-        if result["success"]:
-            self.logger.info("Successfully updated page %s", result.get("page_id", ""))
-        else:
-            self.logger.error(
-                "Error updating page %s: %s", page_id, result.get("message", "")
+            response = await self._client.post(
+                "pages",
+                {
+                    "parent": {"database_id": self.database_id},
+                    "properties": {}  
+                }
             )
+            
+            if response and "id" in response:
+                page_id = response["id"]
+                self.logger.info("Created blank page %s in database %s", page_id, self.database_id)
+                return page_id
+            
+            self.logger.warning("Page creation failed: invalid response")
+            return None
+                
+        except Exception as e:
+            self.logger.error("Error creating blank page: %s", str(e))
+            return None
 
-        return result
-
-    async def delete_page(self, page_id: str) -> PageResult:
+    async def get_page_manager(self, page_id: str) -> Optional[NotionPageManager]:
         """
-        Delete (archive) a page.
+        Get a NotionPageManager for a specific page.
 
         Args:
-            page_id: The ID of the page to delete
+            page_id: The ID of the page
 
         Returns:
-            Result object with success status and message
+            NotionPageManager instance or None if the page wasn't found
         """
-        await self._ensure_initialized()
-
-        self.logger.debug("Deleting page %s", page_id)
-
-        result = await self._page_service.delete_page(page_id)
-
-        if result["success"]:
-            self.logger.info("Successfully deleted page %s", result.get("page_id", ""))
-        else:
-            self.logger.error(
-                "Error deleting page %s: %s", page_id, result.get("message", "")
-            )
-
-        return result
+        self.logger.debug("Getting page manager for page %s", page_id)
+        
+        try:
+            # Check if the page exists
+            page_data = await self._client.get_page(page_id)
+            
+            if not page_data:
+                self.logger.error("Page %s not found", page_id)
+                return None
+                
+            return NotionPageManager(page_id=page_id)
+            
+        except Exception as e:
+            self.logger.error("Error getting page manager: %s", str(e))
+            return None
 
     async def get_pages(
         self,
@@ -257,8 +96,6 @@ class NotionDatabaseManager(LoggingMixin):
         Returns:
             List of NotionPageManager instances for each page
         """
-        await self._ensure_initialized()
-
         self.logger.debug(
             "Getting up to %d pages with filter: %s, sorts: %s",
             limit,
@@ -266,9 +103,19 @@ class NotionDatabaseManager(LoggingMixin):
             sorts,
         )
 
-        pages = await self._query_service.get_pages(
-            self.database_id, limit, filter_conditions, sorts
-        )
+        pages: List[NotionPageManager] = []
+        count = 0
+
+        async for page in self.iter_pages(
+            page_size=min(limit, 100),
+            filter_conditions=filter_conditions,
+            sorts=sorts,
+        ):
+            pages.append(page)
+            count += 1
+
+            if count >= limit:
+                break
 
         self.logger.debug(
             "Retrieved %d pages from database %s", len(pages), self.database_id
@@ -283,6 +130,7 @@ class NotionDatabaseManager(LoggingMixin):
     ) -> AsyncGenerator[NotionPageManager, None]:
         """
         Asynchronous generator that yields pages from the database.
+        Directly queries the Notion API without using the schema.
 
         Args:
             page_size: Number of pages to fetch per request
@@ -292,8 +140,6 @@ class NotionDatabaseManager(LoggingMixin):
         Yields:
             NotionPageManager instances for each page
         """
-        await self._ensure_initialized()
-
         self.logger.debug(
             "Iterating pages with page_size: %d, filter: %s, sorts: %s",
             page_size,
@@ -301,32 +147,100 @@ class NotionDatabaseManager(LoggingMixin):
             sorts,
         )
 
-        async for page_manager in self._query_service.iter_pages(
-            self.database_id, page_size, filter_conditions, sorts
-        ):
-            yield page_manager
+        start_cursor: Optional[str] = None
+        has_more = True
 
-    async def get_page_manager(self, page_id: str) -> Optional[NotionPageManager]:
+        # Prepare the query body
+        body: Dict[str, Any] = {"page_size": page_size}
+
+        if filter_conditions:
+            body["filter"] = filter_conditions
+
+        if sorts:
+            body["sorts"] = sorts
+
+        while has_more:
+            current_body = body.copy()
+            if start_cursor:
+                current_body["start_cursor"] = start_cursor
+
+            result = await self._client.post(
+                f"databases/{self.database_id}/query", data=current_body
+            )
+
+            if not result or "results" not in result:
+                return
+
+            for page in result["results"]:
+                page_id: str = page.get("id", "")
+                title = self._extract_page_title(page)
+                
+                page_url = f"https://notion.so/{page_id.replace('-', '')}"
+
+                notion_page_manager = NotionPageManager(page_id=page_id, title=title, url=page_url)
+                yield notion_page_manager
+
+            # Update pagination parameters
+            has_more = result.get("has_more", False)
+            start_cursor = result.get("next_cursor") if has_more else None
+
+    def _extract_page_title(self, page: Dict[str, Any]) -> str:
         """
-        Get a NotionPageManager for a specific page.
+        Extracts the title from a Notion page object.
 
         Args:
-            page_id: The ID of the page
+            page: The Notion page object
 
         Returns:
-            NotionPageManager instance or None if the page wasn't found
+            The extracted title as a string, or an empty string if no title found
         """
-        await self._ensure_initialized()
+        properties = page.get("properties", {})
+        if not properties:
+            return ""
 
-        self.logger.debug("Getting page manager for page %s", page_id)
+        for prop_value in properties.values():
+            if prop_value.get("type") != "title":
+                continue
+
+            title_array = prop_value.get("title", [])
+            if not title_array:
+                continue
 
-        page_manager = await self._page_service.get_page_manager(page_id)
+            return title_array[0].get("plain_text", "")
+
+        return ""
+
+    async def delete_page(self, page_id: str) -> Dict[str, Any]:
+        """
+        Delete (archive) a page.
 
-        if not page_manager:
-            self.logger.error("Page %s not found", page_id)
+        Args:
+            page_id: The ID of the page to delete
 
-        return page_manager
+        Returns:
+            Dict with success status, message, and page_id when successful
+        """
+        try:
+            formatted_page_id = format_uuid(page_id) or page_id
+            
+            # Archive the page (Notion's way of deleting)
+            data = {"archived": True}
+            
+            result = await self._client.patch(f"pages/{formatted_page_id}", data)
+            if not result:
+                self.logger.error("Error deleting page %s", formatted_page_id)
+                return {
+                    "success": False,
+                    "message": f"Failed to delete page {formatted_page_id}",
+                }
+            
+            self.logger.info("Page %s successfully deleted (archived)", formatted_page_id)
+            return {"success": True, "page_id": formatted_page_id}
+            
+        except Exception as e:
+            self.logger.error("Error in delete_page: %s", str(e))
+            return {"success": False, "message": f"Error: {str(e)}"}
 
     async def close(self) -> None:
         """Close the client connection."""
-        await self._client.close()
+        await self._client.close()

notionary/core/database/notion_database_manager_factory.py

@@ -12,7 +12,7 @@ from notionary.exceptions.database_exceptions import (
     NotionDatabaseException,
 )
 from notionary.util.logging_mixin import LoggingMixin
-from notionary.util.uuid_utils import format_uuid
+from notionary.util.page_id_utils import format_uuid
 
 
 class NotionDatabaseFactory(LoggingMixin):
@@ -44,21 +44,11 @@ class NotionDatabaseFactory(LoggingMixin):
 
         try:
             formatted_id = format_uuid(database_id) or database_id
-
+            
             manager = NotionDatabaseManager(formatted_id, token)
+            
 
-            success = await manager.initialize()
-
-            if not success:
-                error_msg = (
-                    f"Failed to initialize database manager for ID: {formatted_id}"
-                )
-                logger.error(error_msg)
-                raise DatabaseInitializationError(formatted_id, error_msg)
-
-            logger.info(
-                lambda: f"Successfully created database manager for ID: {formatted_id}"
-            )
+            logger.info("Successfully created database manager for ID: %s", formatted_id)
             return manager
 
         except DatabaseInitializationError:
@@ -88,7 +78,7 @@ class NotionDatabaseFactory(LoggingMixin):
             An initialized NotionDatabaseManager instance
         """
         logger = cls.class_logger()
-        logger.debug(lambda: f"Searching for database with name: {database_name}")
+        logger.debug("Searching for database with name: %s", database_name)
 
         client = NotionClient(token=token)
 
@@ -116,11 +106,8 @@ class NotionDatabaseFactory(LoggingMixin):
                 logger.warning(error_msg)
                 raise DatabaseNotFoundException(database_name, error_msg)
 
-            logger.debug(
-                lambda: f"Found {len(databases)} databases, searching for best match"
-            )
+            logger.debug("Found %d databases, searching for best match", len(databases))
 
-            # Find best match using fuzzy matching
             best_match = None
             best_score = 0
 
@@ -135,7 +122,6 @@ class NotionDatabaseFactory(LoggingMixin):
                     best_score = score
                     best_match = db
 
-            # Use a minimum threshold for match quality (0.6 = 60% similarity)
             if best_score < 0.6 or not best_match:
                 error_msg = f"No good database name match found for '{database_name}'. Best match had score {best_score:.2f}"
                 logger.warning(error_msg)
@@ -150,23 +136,11 @@ class NotionDatabaseFactory(LoggingMixin):
 
             matched_name = cls._extract_title_from_database(best_match)
 
-            logger.info(
-                lambda: f"Found matching database: '{matched_name}' (ID: {database_id}) with score: {best_score:.2f}"
-            )
+            logger.info("Found matching database: '%s' (ID: %s) with score: %.2f", matched_name, database_id, best_score)
 
             manager = NotionDatabaseManager(database_id, token)
-            success = await manager.initialize()
 
-            if not success:
-                error_msg = (
-                    f"Failed to initialize database manager for database {database_id}"
-                )
-                logger.error(error_msg)
-                raise DatabaseInitializationError(database_id, error_msg)
-
-            logger.info(
-                lambda: f"Successfully created database manager for '{matched_name}'"
-            )
+            logger.info(f"Successfully created database manager for '{matched_name}'")
             await client.close()
             return manager
 
@@ -183,22 +157,11 @@ class NotionDatabaseFactory(LoggingMixin):
     def _extract_title_from_database(cls, database: Dict[str, Any]) -> str:
         """
         Extract the title from a database object.
-
-        Args:
-            database: A database object from the Notion API
-
-        Returns:
-            The extracted title or "Untitled" if no title is found
-
-        Raises:
-            DatabaseParsingError: If there's an error parsing the database title
         """
         try:
-            # Check for title in the root object
             if "title" in database:
                 return cls._extract_text_from_rich_text(database["title"])
 
-            # Check for title in properties
             if "properties" in database and "title" in database["properties"]:
                 title_prop = database["properties"]["title"]
                 if "title" in title_prop:
@@ -215,12 +178,6 @@ class NotionDatabaseFactory(LoggingMixin):
     def _extract_text_from_rich_text(cls, rich_text: List[Dict[str, Any]]) -> str:
         """
         Extract plain text from a rich text array.
-
-        Args:
-            rich_text: A list of rich text objects from Notion API
-
-        Returns:
-            The concatenated plain text content
         """
         if not rich_text:
             return ""
@@ -230,4 +187,4 @@ class NotionDatabaseFactory(LoggingMixin):
             if "plain_text" in text_obj:
                 text_parts.append(text_obj["plain_text"])
 
-        return "".join(text_parts)
+        return "".join(text_parts)