notionary 0.2.12__py3-none-any.whl → 0.2.14__py3-none-any.whl

notionary/page/client.py

@@ -0,0 +1,110 @@
+from typing import Dict, Any, List, Optional
+from notionary.base_notion_client import BaseNotionClient
+from notionary.models.notion_page_response import NotionPageResponse
+from notionary.models.notion_database_response import NotionQueryDatabaseResponse
+from notionary.util import singleton
+
+
+@singleton
+class NotionPageClient(BaseNotionClient):
+    """
+    Client for Notion page-specific operations.
+    Inherits base HTTP functionality from BaseNotionClient.
+    """
+
+    async def get_page(self, page_id: str) -> NotionPageResponse:
+        """
+        Gets metadata for a Notion page by its ID.
+        """
+        response = await self.get(f"pages/{page_id}")
+        return NotionPageResponse.model_validate(response)
+
+    async def create_page(
+        self,
+        parent_database_id: Optional[str] = None,
+        properties: Optional[Dict[str, Any]] = None,
+    ) -> NotionPageResponse:
+        """
+        Creates a new page in a Notion database or as a child page.
+        """
+        page_data = {
+            "parent": {"database_id": parent_database_id} if parent_database_id else {},
+            "properties": properties or {},
+        }
+
+        response = await self.post("pages", page_data)
+        return NotionPageResponse.model_validate(response)
+
+    async def patch_page(
+        self, page_id: str, data: Optional[Dict[str, Any]] = None
+    ) -> NotionPageResponse:
+        """
+        Updates a Notion page with the provided data.
+        """
+        response = await self.patch(f"pages/{page_id}", data=data)
+        return NotionPageResponse.model_validate(response)
+
+    async def delete_page(self, page_id: str) -> bool:
+        """
+        Deletes (archives) a Notion page.
+        """
+        # Notion doesn't have a direct delete endpoint, we archive by setting archived=True
+        data = {"archived": True}
+        response = await self.patch(f"pages/{page_id}", data=data)
+        return response is not None
+
+    async def search_pages(
+        self, query: str, sort_ascending: bool = True, limit: int = 100
+    ) -> NotionQueryDatabaseResponse:
+        """
+        Searches for pages in Notion using the search endpoint.
+        """
+        from notionary.page.search_filter_builder import SearchFilterBuilder
+
+        search_filter = (
+            SearchFilterBuilder()
+            .with_query(query)
+            .with_pages_only()
+            .with_sort_direction("ascending" if sort_ascending else "descending")
+            .with_page_size(limit)
+        )
+
+        result = await self.post("search", search_filter.build())
+        return NotionQueryDatabaseResponse.model_validate(result)
+
+    async def update_page_properties(
+        self, page_id: str, properties: Dict[str, Any]
+    ) -> NotionPageResponse:
+        """
+        Updates only the properties of a Notion page.
+        """
+        data = {"properties": properties}
+        return await self.patch_page(page_id, data)
+
+    async def archive_page(self, page_id: str) -> NotionPageResponse:
+        """
+        Archives a Notion page (soft delete).
+        """
+        data = {"archived": True}
+        return await self.patch_page(page_id, data)
+
+    async def unarchive_page(self, page_id: str) -> NotionPageResponse:
+        """
+        Unarchives a previously archived Notion page.
+        """
+        data = {"archived": False}
+        return await self.patch_page(page_id, data)
+
+    async def get_page_blocks(self, page_id: str) -> List[Dict[str, Any]]:
+        """
+        Retrieves all blocks of a Notion page.
+        """
+        response = await self.get(f"blocks/{page_id}/children")
+        return response.get("results", [])
+
+    async def get_block_children(self, block_id: str) -> List[Dict[str, Any]]:
+        """
+        Retrieves all children blocks of a specific block.
+        """
+        response = await self.get(f"blocks/{block_id}/children")
+        return response.get("results", [])

notionary/page/content/page_content_retriever.py

@@ -1,8 +1,8 @@
 from typing import Any, Dict, List, Optional
 
-from notionary.elements.registry.block_registry import BlockRegistry
-from notionary.notion_client import NotionClient
+from notionary.blocks.registry.block_registry import BlockRegistry
 
+from notionary.blocks import NotionBlockClient
 from notionary.page.notion_to_markdown_converter import (
     NotionToMarkdownConverter,
 )
@@ -13,14 +13,13 @@ class PageContentRetriever(LoggingMixin):
     def __init__(
         self,
         page_id: str,
-        client: NotionClient,
         block_registry: BlockRegistry,
     ):
         self.page_id = page_id
-        self._client = client
         self._notion_to_markdown_converter = NotionToMarkdownConverter(
             block_registry=block_registry
         )
+        self.client = NotionBlockClient()
 
     async def get_page_content(self) -> str:
         blocks = await self._get_page_blocks_with_children()
@@ -30,9 +29,9 @@ class PageContentRetriever(LoggingMixin):
         self, parent_id: Optional[str] = None
     ) -> List[Dict[str, Any]]:
         blocks = (
-            await self._get_blocks()
+            await self.client.get_page_blocks(page_id=self.page_id)
             if parent_id is None
-            else await self._get_block_children(parent_id)
+            else await self.client.get_block_children(parent_id)
         )
 
         if not blocks:
@@ -51,17 +50,3 @@ class PageContentRetriever(LoggingMixin):
                 block["children"] = children
 
         return blocks
-
-    async def _get_blocks(self) -> List[Dict[str, Any]]:
-        result = await self._client.get(f"blocks/{self.page_id}/children")
-        if not result:
-            self.logger.error("Error retrieving page content: %s", result.error)
-            return []
-        return result.get("results", [])
-
-    async def _get_block_children(self, block_id: str) -> List[Dict[str, Any]]:
-        result = await self._client.get(f"blocks/{block_id}/children")
-        if not result:
-            self.logger.error("Error retrieving block children: %s", result.error)
-            return []
-        return result.get("results", [])

notionary/page/content/page_content_writer.py

@@ -1,9 +1,8 @@
 from typing import Any, Dict
 
-from notionary.elements.divider_element import DividerElement
-from notionary.elements.registry.block_registry import BlockRegistry
-from notionary.notion_client import NotionClient
+from notionary.blocks import DividerElement, BlockRegistry
 
+from notionary.page.client import NotionPageClient
 from notionary.page.formatting.markdown_to_notion_converter import (
     MarkdownToNotionConverter,
 )
@@ -20,7 +19,7 @@ class PageContentWriter(LoggingMixin):
     def __init__(
         self,
         page_id: str,
-        client: NotionClient,
+        client: NotionPageClient,
         block_registry: BlockRegistry,
     ):
         self.page_id = page_id

notionary/page/formatting/markdown_to_notion_converter.py

@@ -1,9 +1,7 @@
 import re
 from typing import Dict, Any, List, Optional, Tuple
 
-from notionary.elements.column_element import ColumnElement
-from notionary.elements.registry.block_registry import BlockRegistry
-from notionary.elements.registry.block_registry_builder import BlockRegistryBuilder
+from notionary.blocks import ColumnElement, BlockRegistry, BlockRegistryBuilder
 from notionary.page.formatting.spacer_rules import SpacerRule, SpacerRuleEngine
 
 

notionary/{prompting → page}/markdown_syntax_prompt_generator.py

@@ -1,6 +1,5 @@
 from typing import Type, List
-from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.elements.text_inline_formatter import TextInlineFormatter
+from notionary.blocks import NotionBlockElement
 
 
 class MarkdownSyntaxPromptGenerator: