notionary 0.2.19__py3-none-any.whl → 0.2.22__py3-none-any.whl

notionary/page/models.py

@@ -0,0 +1,327 @@
+from typing import Any, Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict
+
+
+class TextContent(BaseModel):
+    content: str
+    link: Optional[str] = None
+
+
+class RichText(BaseModel):
+    type: str
+    text: TextContent
+    plain_text: str
+    href: Optional[str] = None
+
+
+class User(BaseModel):
+    object: str
+    id: str
+
+
+class Parent(BaseModel):
+    type: Literal["page_id", "workspace", "block_id", "database_id"]
+    page_id: Optional[str] = None
+    block_id: Optional[str] = None
+    database_id: Optional[str] = None
+
+
+# Rich text types for Pydantic models
+class TextContentPydantic(BaseModel):
+    content: str
+    link: Optional[dict[str, str]] = None
+
+
+class Annotations(BaseModel):
+    bold: bool
+    italic: bool
+    strikethrough: bool
+    underline: bool
+    code: bool
+    color: str
+
+
+class RichTextItemPydantic(BaseModel):
+    type: str  # 'text', 'mention', 'equation'
+    text: Optional[TextContentPydantic] = None
+    annotations: Annotations
+    plain_text: str
+    href: Optional[str] = None
+
+
+# Cover and Icon types
+class ExternalFile(BaseModel):
+    """Represents an external file, e.g., for cover images."""
+
+    url: str
+
+
+class Cover(BaseModel):
+    """Cover image for a Notion page."""
+
+    type: str
+    external: ExternalFile
+
+
+class EmojiIcon(BaseModel):
+    type: Literal["emoji"]
+    emoji: str
+
+
+class ExternalIcon(BaseModel):
+    type: Literal["external"]
+    external: ExternalFile
+
+
+Icon = Union[EmojiIcon, ExternalIcon]
+
+
+# Database property schema types (these are schema definitions, not values)
+class StatusOption(BaseModel):
+    id: str
+    name: str
+    color: str
+    description: Optional[str] = None
+
+
+class StatusGroup(BaseModel):
+    id: str
+    name: str
+    color: str
+    option_ids: list[str]
+
+
+class StatusPropertySchema(BaseModel):
+    options: list[StatusOption]
+    groups: list[StatusGroup]
+
+
+class DatabaseStatusProperty(BaseModel):
+    id: str
+    name: str
+    type: Literal["status"]
+    status: StatusPropertySchema
+
+
+class RelationPropertySchema(BaseModel):
+    database_id: str
+    type: str  # "single_property"
+    single_property: dict[str, Any]
+
+
+class DatabaseRelationProperty(BaseModel):
+    id: str
+    name: str
+    type: Literal["relation"]
+    relation: RelationPropertySchema
+
+
+class DatabaseUrlProperty(BaseModel):
+    id: str
+    name: str
+    type: Literal["url"]
+    url: dict[str, Any]  # Usually empty dict
+
+
+class DatabaseRichTextProperty(BaseModel):
+    id: str
+    name: str
+    type: Literal["rich_text"]
+    rich_text: dict[str, Any]  # Usually empty dict
+
+
+class MultiSelectOption(BaseModel):
+    id: str
+    name: str
+    color: str
+    description: Optional[str] = None
+
+
+class MultiSelectPropertySchema(BaseModel):
+    options: list[MultiSelectOption]
+
+
+class DatabaseMultiSelectProperty(BaseModel):
+    id: str
+    name: str
+    type: Literal["multi_select"]
+    multi_select: MultiSelectPropertySchema
+
+
+class DatabaseTitleProperty(BaseModel):
+    id: str
+    name: str
+    type: Literal["title"]
+    title: dict[str, Any]  # Usually empty dict
+
+
+# Generic database property for unknown types
+class GenericDatabaseProperty(BaseModel):
+    id: str
+    name: str
+    type: str
+
+    model_config = ConfigDict(extra="allow")
+
+
+# Union of all database property types
+DatabaseProperty = Union[
+    DatabaseStatusProperty,
+    DatabaseRelationProperty,
+    DatabaseUrlProperty,
+    DatabaseRichTextProperty,
+    DatabaseMultiSelectProperty,
+    DatabaseTitleProperty,
+    GenericDatabaseProperty,
+]
+
+
+# Page property value types (these are actual values, not schemas)
+class StatusValue(BaseModel):
+    id: str
+    name: str
+    color: str
+
+
+class StatusProperty(BaseModel):
+    id: str
+    type: str  # 'status'
+    status: Optional[StatusValue] = None
+
+
+class RelationItem(BaseModel):
+    id: str
+
+
+class RelationProperty(BaseModel):
+    id: str
+    type: str  # 'relation'
+    relation: list[RelationItem]
+    has_more: bool
+
+
+class UrlProperty(BaseModel):
+    id: str
+    type: str  # 'url'
+    url: Optional[str] = None
+
+
+class RichTextProperty(BaseModel):
+    id: str
+    type: str  # 'rich_text'
+    rich_text: list[RichTextItemPydantic]
+
+
+class MultiSelectItem(BaseModel):
+    id: str
+    name: str
+    color: str
+
+
+class MultiSelectProperty(BaseModel):
+    id: str
+    type: str  # 'multi_select'
+    multi_select: list[MultiSelectItem]
+
+
+class TitleProperty(BaseModel):
+    id: str
+    type: str  # 'title'
+    title: list[RichTextItemPydantic]
+
+
+# Cover types
+class ExternalCover(BaseModel):
+    url: str
+
+
+class NotionCover(BaseModel):
+    type: str  # 'external', 'file'
+    external: Optional[ExternalCover] = None
+
+
+# Parent types for Pydantic
+class NotionParent(BaseModel):
+    type: str  # 'database_id', 'page_id', 'workspace'
+    database_id: Optional[str] = None
+    page_id: Optional[str] = None
+
+
+# User type for Pydantic
+class NotionUser(BaseModel):
+    object: str  # 'user'
+    id: str
+
+
+# Database object
+class NotionDatabaseResponse(BaseModel):
+    """
+    Represents the response from the Notion API when retrieving a database.
+    """
+
+    object: Literal["database"]
+    id: str
+    cover: Optional[Cover] = None
+    icon: Optional[Icon] = None
+    created_time: str
+    last_edited_time: str
+    created_by: NotionUser
+    last_edited_by: NotionUser
+    title: list[RichTextItemPydantic]
+    description: list[Any]
+    is_inline: bool
+    properties: dict[
+        str, Any
+    ]  # Using Any for flexibility with different property schemas
+    parent: NotionParent
+    url: str
+    public_url: Optional[str] = None
+    archived: bool
+    in_trash: bool
+
+
+class NotionPageResponse(BaseModel):
+    object: Literal["page"]
+    id: str
+    created_time: str
+    last_edited_time: str
+    created_by: NotionUser
+    last_edited_by: NotionUser
+    cover: Optional[NotionCover] = None
+    icon: Optional[Icon] = None
+    parent: NotionParent
+    archived: bool
+    in_trash: bool
+    properties: dict[str, Any]
+    url: str
+    public_url: Optional[str] = None
+
+
+# Specific response type for database queries (pages only)
+class NotionQueryDatabaseResponse(BaseModel):
+    """
+    Notion database query response model for querying pages within a database.
+    """
+
+    object: Literal["list"]
+    results: list[NotionPageResponse]
+    next_cursor: Optional[str] = None
+    has_more: bool
+    type: Literal["page_or_database"]
+    page_or_database: dict[str, Any]
+    request_id: str
+
+
+class NotionDatabaseSearchResponse(BaseModel):
+    """
+    Notion search response model for database-only searches.
+    """
+
+    object: Literal["list"]
+    results: list[NotionDatabaseResponse]
+    next_cursor: Optional[str] = None
+    has_more: bool
+    type: Literal["page_or_database"]
+    page_or_database: dict[str, Any]
+    request_id: str

notionary/page/notion_page.py

@@ -1,40 +1,44 @@
 from __future__ import annotations
+
 import asyncio
-from typing import Any, Dict, Optional, TYPE_CHECKING
 import random
-
-from notionary.blocks import BlockRegistry
-from notionary.models.notion_database_response import NotionPageResponse
-from notionary.models.notion_page_response import DatabaseParent
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+
+from notionary.blocks.client import NotionBlockClient
+from notionary.blocks.syntax_prompt_builder import SyntaxPromptBuilder
+from notionary.blocks.models import DatabaseParent
+from notionary.blocks.registry.block_registry import BlockRegistry
+from notionary.blocks.registry.block_registry_builder import BlockRegistryBuilder
+from notionary.database.client import NotionDatabaseClient
+from notionary.markdown.markdown_builder import MarkdownBuilder
 from notionary.page.client import NotionPageClient
-from notionary.page.content.page_content_retriever import PageContentRetriever
-
-
-from notionary.page.content.page_content_writer import PageContentWriter
+from notionary.page.models import NotionPageResponse
+from notionary.page.page_content_deleting_service import PageContentDeletingService
+from notionary.page.page_content_writer import PageContentWriter
 from notionary.page.property_formatter import NotionPropertyFormatter
+from notionary.page.reader.page_content_retriever import PageContentRetriever
 from notionary.page.utils import extract_property_value
-
-from notionary.util import LoggingMixin, format_uuid, factory_only
+from notionary.util import LoggingMixin, extract_uuid, factory_only, format_uuid
 from notionary.util.fuzzy import find_best_match
 
-
 if TYPE_CHECKING:
     from notionary import NotionDatabase
 
-
 class NotionPage(LoggingMixin):
     """
     Managing content and metadata of a Notion page.
     """
 
-    @factory_only("from_page_id", "from_page_name")
+    @factory_only("from_page_id", "from_page_name", "from_url")
     def __init__(
         self,
         page_id: str,
         title: str,
         url: str,
+        archived: bool,
+        in_trash: bool,
         emoji_icon: Optional[str] = None,
-        properties: Optional[Dict[str, Any]] = None,
+        properties: Optional[dict[str, Any]] = None,
         parent_database: Optional[NotionDatabase] = None,
         token: Optional[str] = None,
     ):
@@ -44,23 +48,30 @@ class NotionPage(LoggingMixin):
         self._page_id = page_id
         self._title = title
         self._url = url
+        self._is_archived = archived
+        self._is_in_trash = in_trash
         self._emoji_icon = emoji_icon
         self._properties = properties
         self._parent_database = parent_database
 
         self._client = NotionPageClient(token=token)
+        self._block_client = NotionBlockClient(token=token)
         self._page_data = None
-
-        self._block_element_registry = BlockRegistry.create_registry()
+        
+        self.block_element_registry = BlockRegistry.create_registry()
 
         self._page_content_writer = PageContentWriter(
             page_id=self._page_id,
-            block_registry=self._block_element_registry,
+            block_registry=self.block_element_registry,
         )
 
-        self._page_content_retriever = PageContentRetriever(
+        self._page_content_deleting_service = PageContentDeletingService(
             page_id=self._page_id,
-            block_registry=self._block_element_registry,
+            block_registry=self.block_element_registry,
+        )
+
+        self._page_content_retriever = PageContentRetriever(
+            block_registry=self.block_element_registry,
         )
 
     @classmethod
@@ -69,10 +80,6 @@ class NotionPage(LoggingMixin):
     ) -> NotionPage:
         """
         Create a NotionPage from a page ID.
-
-        Args:
-            page_id: The ID of the Notion page
-            token: Optional Notion API token (uses environment variable if not provided)
         """
         formatted_id = format_uuid(page_id) or page_id
 
@@ -131,6 +138,26 @@ class NotionPage(LoggingMixin):
             cls.logger.error("Error finding page by name: %s", str(e))
             raise
 
+    @classmethod
+    async def from_url(cls, url: str, token: Optional[str] = None) -> NotionPage:
+        """
+        Create a NotionPage from a Notion page URL.
+        """
+        try:
+            page_id = extract_uuid(url)
+            if not page_id:
+                raise ValueError(f"Could not extract page ID from URL: {url}")
+
+            formatted_id = format_uuid(page_id) or page_id
+
+            async with NotionPageClient(token=token) as client:
+                page_response = await client.get_page(formatted_id)
+                return await cls._create_from_response(page_response, token)
+
+        except Exception as e:
+            cls.logger.error("Error creating page from URL '%s': %s", url, str(e))
+            raise
+
     @property
     def id(self) -> str:
         """
@@ -161,30 +188,30 @@ class NotionPage(LoggingMixin):
         return self._emoji_icon
 
     @property
-    def properties(self) -> Optional[Dict[str, Any]]:
+    def properties(self) -> Optional[dict[str, Any]]:
         """
         Get the properties of the page.
         """
         return self._properties
 
     @property
-    def block_registry(self) -> BlockRegistry:
-        """
-        Get the block element registry associated with this page.
+    def is_archived(self) -> bool:
+        return self._is_archived
 
-        Returns:
-            BlockElementRegistry: The registry of block elements.
-        """
-        return self._block_element_registry
+    @property
+    def is_in_trash(self) -> bool:
+        return self._is_in_trash
 
-    def get_notion_markdown_system_prompt(self) -> str:
+    @property
+    def block_registry_builder(self) -> BlockRegistryBuilder:
         """
-        Get the formatting prompt for the page content manager.
-
-        Returns:
-            str: The formatting prompt.
+        Returns the block registry builder for this page.
         """
-        return self._block_element_registry.get_notion_markdown_syntax_prompt()
+        return self.block_element_registry.builder
+
+    def get_prompt_information(self) -> str:
+        markdown_syntax_builder = SyntaxPromptBuilder()
+        return markdown_syntax_builder.build_concise_reference()
 
     async def set_title(self, title: str) -> str:
         """
@@ -205,38 +232,65 @@ class NotionPage(LoggingMixin):
         except Exception as e:
             self.logger.error("Error setting page title: %s", str(e))
 
-    async def append_markdown(self, markdown: str, append_divider=False) -> bool:
+    async def append_markdown(
+        self,
+        content: Union[str, Callable[[MarkdownBuilder], MarkdownBuilder]],
+        *,
+        prepend_table_of_contents: bool = False,
+        append_divider: bool = False,
+    ) -> bool:
         """
         Append markdown content to the page.
-        """
-        return await self._page_content_writer.append_markdown(
-            markdown_text=markdown, append_divider=append_divider
-        )
 
-    async def clear_page_content(self) -> bool:
-        """
-        Clear all content from the page.
+        Args:
+            content: Either raw markdown text OR a callback function that receives a MarkdownBuilder
+            prepend_table_of_contents: Whether to prepend table of contents
+            append_divider: Whether to append a divider
+
+        Returns:
+            bool: True if successful, False otherwise
         """
-        return await self._page_content_writer.clear_page_content()
+        result = await self._page_content_writer.append_markdown(
+            content=content,
+            append_divider=append_divider,
+            prepend_table_of_contents=prepend_table_of_contents,
+        )
+        return result is not None
 
-    async def replace_content(self, markdown: str) -> bool:
+    async def replace_content(
+        self,
+        content: Union[str, Callable[[MarkdownBuilder], MarkdownBuilder]],
+        *,
+        prepend_table_of_contents: bool = False,
+        append_divider: bool = False,
+    ) -> bool:
         """
         Replace the entire page content with new markdown content.
 
         Args:
-            markdown: The new markdown content.
+            content: Either raw markdown text OR a callback function that receives a MarkdownBuilder
+            prepend_table_of_contents: Whether to prepend table of contents
+            append_divider: Whether to append a divider
 
         Returns:
-            str: Status or confirmation message.
+            bool: True if successful, False otherwise
         """
-        clear_result = await self._page_content_writer.clear_page_content()
+        clear_result = await self._page_content_deleting_service.clear_page_content()
         if not clear_result:
             self.logger.error("Failed to clear page content before replacement")
-            return False
 
-        return await self._page_content_writer.append_markdown(
-            markdown_text=markdown, append_divider=False
+        result = await self._page_content_writer.append_markdown(
+            content=content,
+            prepend_table_of_contents=prepend_table_of_contents,
+            append_divider=append_divider,
         )
+        return result is not None
+
+    async def clear_page_content(self) -> str:
+        """
+        Clear all content from the page.
+        """
+        return await self._page_content_deleting_service.clear_page_content()
 
     async def get_text_content(self) -> str:
         """
@@ -245,7 +299,10 @@ class NotionPage(LoggingMixin):
         Returns:
             str: The text content of the page.
         """
-        return await self._page_content_retriever.get_page_content()
+        blocks = await self._block_client.get_blocks_by_page_id_recursively(
+            page_id=self._page_id
+        )
+        return await self._page_content_retriever.convert_to_markdown(blocks=blocks)
 
     async def set_emoji_icon(self, emoji: str) -> Optional[str]:
         """
@@ -263,7 +320,27 @@ class NotionPage(LoggingMixin):
 
             self.logger.error(f"Error updating page emoji: {str(e)}")
             return None
-
+        
+    async def create_child_database(self, title: str) -> NotionDatabase:
+        from notionary import NotionDatabase
+        database_client = NotionDatabaseClient(token=self._client.token)
+        
+        create_database_response =  await database_client.create_database(
+            title=title,
+            parent_page_id=self._page_id,
+        )
+        
+        return await NotionDatabase.from_database_id(id=create_database_response.id, token=self._client.token)
+    
+    async def create_child_page(self, title: str) -> NotionPage:
+        from notionary import NotionPage
+        child_page_response = await self._client.create_page(
+            parent_page_id=self._page_id,
+            title=title,
+        )
+        
+        return await NotionPage.from_page_id(page_id=child_page_response.id, token=self._client.token)
+    
     async def set_external_icon(self, url: str) -> Optional[str]:
         """
         Sets the page icon to an external image.
@@ -385,7 +462,6 @@ class NotionPage(LoggingMixin):
             )
             return []
 
-    # Diese Methode hier sollte auch für relation properties funktionieren aber gerne auch eine dedizierte hier
     async def set_property_value_by_name(self, property_name: str, value: Any) -> Any:
         """
         Set the value of a specific property by its name.
@@ -509,6 +585,8 @@ class NotionPage(LoggingMixin):
             title=title,
             url=page_response.url,
             emoji_icon=emoji,
+            archived=page_response.archived,
+            in_trash=page_response.in_trash,
             properties=page_response.properties,
             parent_database=parent_database,
             token=token,
@@ -558,4 +636,4 @@ class NotionPage(LoggingMixin):
         """Extract parent database ID from page response."""
         parent = page_response.parent
         if isinstance(parent, DatabaseParent):
-            return parent.database_id
+            return parent.database_id