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

notionary/markdown/markdown_document_model.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+from typing import Literal, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from notionary.blocks.bookmark.bookmark_markdown_node import BookmarkMarkdownBlockParams
+from notionary.blocks.bulleted_list.bulleted_list_markdown_node import (
+    BulletedListMarkdownBlockParams,
+)
+from notionary.blocks.callout.callout_markdown_node import CalloutMarkdownBlockParams
+from notionary.blocks.divider.divider_markdown_node import DividerMarkdownBlockParams
+from notionary.blocks.embed.embed_markdown_node import EmbedMarkdownBlockParams
+from notionary.blocks.equation.equation_element_markdown_node import (
+    EquationMarkdownBlockParams,
+)
+from notionary.blocks.file.file_element_markdown_node import FileMarkdownNodeParams
+
+# Import all the existing params models
+from notionary.blocks.heading.heading_markdown_node import HeadingMarkdownBlockParams
+from notionary.blocks.image_block.image_markdown_node import ImageMarkdownBlockParams
+from notionary.blocks.numbered_list.numbered_list_markdown_node import (
+    NumberedListMarkdownBlockParams,
+)
+from notionary.blocks.paragraph.paragraph_markdown_node import (
+    ParagraphMarkdownBlockParams,
+)
+from notionary.blocks.quote.quote_markdown_node import QuoteMarkdownBlockParams
+from notionary.blocks.table.table_markdown_node import TableMarkdownBlockParams
+from notionary.blocks.table_of_contents.table_of_contents_markdown_node import (
+    TableOfContentsMarkdownBlockParams,
+)
+from notionary.blocks.todo.todo_markdown_node import TodoMarkdownBlockParams
+from notionary.blocks.video.video_markdown_node import VideoMarkdownBlockParams
+
+
+class HeadingBlock(BaseModel):
+    type: Literal["heading"] = "heading"
+    params: HeadingMarkdownBlockParams
+
+
+class ParagraphBlock(BaseModel):
+    type: Literal["paragraph"] = "paragraph"
+    params: ParagraphMarkdownBlockParams
+
+
+class QuoteBlock(BaseModel):
+    type: Literal["quote"] = "quote"
+    params: QuoteMarkdownBlockParams
+
+
+class BulletedListBlock(BaseModel):
+    type: Literal["bulleted_list"] = "bulleted_list"
+    params: BulletedListMarkdownBlockParams
+
+
+class NumberedListBlock(BaseModel):
+    type: Literal["numbered_list"] = "numbered_list"
+    params: NumberedListMarkdownBlockParams
+
+
+class TodoBlock(BaseModel):
+    type: Literal["todo"] = "todo"
+    params: TodoMarkdownBlockParams
+
+
+class CalloutBlock(BaseModel):
+    type: Literal["callout"] = "callout"
+    params: CalloutMarkdownBlockParams
+
+
+class CodeBlock(BaseModel):
+    type: Literal["code"] = "code"
+    params: CodeBlock
+
+
+class ImageBlock(BaseModel):
+    type: Literal["image"] = "image"
+    params: ImageMarkdownBlockParams
+
+
+class VideoBlock(BaseModel):
+    type: Literal["video"] = "video"
+    params: VideoMarkdownBlockParams
+
+
+class AudioBlock(BaseModel):
+    type: Literal["audio"] = "audio"
+    params: FileMarkdownNodeParams
+
+
+class FileBlock(BaseModel):
+    type: Literal["file"] = "file"
+    params: FileMarkdownNodeParams
+
+
+class PdfBlock(BaseModel):
+    type: Literal["pdf"] = "pdf"
+    params: FileMarkdownNodeParams
+
+
+class BookmarkBlock(BaseModel):
+    type: Literal["bookmark"] = "bookmark"
+    params: BookmarkMarkdownBlockParams
+
+
+class EmbedBlock(BaseModel):
+    type: Literal["embed"] = "embed"
+    params: EmbedMarkdownBlockParams
+
+
+class TableBlock(BaseModel):
+    type: Literal["table"] = "table"
+    params: TableMarkdownBlockParams
+
+
+class DividerBlock(BaseModel):
+    type: Literal["divider"] = "divider"
+    params: DividerMarkdownBlockParams
+
+
+class EquationBlock(BaseModel):
+    type: Literal["equation"] = "equation"
+    params: EquationMarkdownBlockParams
+
+
+class TableOfContentsBlock(BaseModel):
+    type: Literal["table_of_contents"] = "table_of_contents"
+    params: TableOfContentsMarkdownBlockParams
+
+
+# Special blocks for nested content
+class ToggleBlockParams(BaseModel):
+    title: str
+    children: list[MarkdownBlock] = Field(default_factory=list)
+
+
+class ToggleBlock(BaseModel):
+    type: Literal["toggle"] = "toggle"
+    params: ToggleBlockParams
+
+
+class ToggleableHeadingBlockParams(BaseModel):
+    text: str
+    level: int = Field(ge=1, le=3)
+    children: list[MarkdownBlock] = Field(default_factory=list)
+
+
+class ToggleableHeadingBlock(BaseModel):
+    type: Literal["toggleable_heading"] = "toggleable_heading"
+    params: ToggleableHeadingBlockParams
+
+
+class ColumnBlockParams(BaseModel):
+    columns: list[list[MarkdownBlock]] = Field(default_factory=list)
+    width_ratios: Optional[list[float]] = None
+
+
+class ColumnBlock(BaseModel):
+    type: Literal["columns"] = "columns"
+    params: ColumnBlockParams
+
+
+# Union of all possible blocks
+MarkdownBlock = Union[
+    HeadingBlock,
+    ParagraphBlock,
+    QuoteBlock,
+    BulletedListBlock,
+    NumberedListBlock,
+    TodoBlock,
+    CalloutBlock,
+    CodeBlock,
+    ImageBlock,
+    VideoBlock,
+    AudioBlock,
+    FileBlock,
+    PdfBlock,
+    BookmarkBlock,
+    EmbedBlock,
+    TableBlock,
+    DividerBlock,
+    EquationBlock,
+    TableOfContentsBlock,
+    ToggleBlock,
+    ToggleableHeadingBlock,
+    ColumnBlock,
+]
+
+
+# Update forward references
+ToggleBlockParams.model_rebuild()
+ToggleableHeadingBlockParams.model_rebuild()
+ColumnBlockParams.model_rebuild()
+
+
+class MarkdownDocumentModel(BaseModel):
+    """
+    Complete document model for generating Markdown via MarkdownBuilder.
+    Perfect for LLM structured output!
+
+    Example:
+        {
+            "blocks": [
+                {
+                    "type": "heading",
+                    "params": {"text": "My Document", "level": 1}
+                },
+                {
+                    "type": "paragraph",
+                    "params": {"text": "Introduction text"}
+                },
+                {
+                    "type": "pdf",
+                    "params": {"url": "https://example.com/doc.pdf", "caption": "Important PDF"}
+                }
+            ]
+        }
+    """
+
+    blocks: list[MarkdownBlock] = Field(default_factory=list)
+
+    def to_markdown(self) -> str:
+        """Convert the model directly to markdown string."""
+        from notionary.markdown.markdown_builder import MarkdownBuilder
+
+        builder = MarkdownBuilder.from_model(self)
+        return builder.build()

notionary/{blocks → markdown}/markdown_node.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from abc import ABC, abstractmethod
 
 

notionary/models/notion_database_response.py

@@ -1,338 +0,0 @@
-from pydantic import BaseModel
-from dataclasses import dataclass
-from typing import Optional, List, Dict, Any, Literal, Union
-
-from notionary.models.notion_page_response import Cover, Icon
-
-
-# Reusing existing types from your codebase
-@dataclass
-class TextContent:
-    content: str
-    link: Optional[str] = None
-
-
-@dataclass
-class RichText:
-    type: str
-    text: TextContent
-    plain_text: str
-    href: Optional[str]
-
-
-@dataclass
-class User:
-    object: str
-    id: str
-
-
-@dataclass
-class Parent:
-    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
-
-
-# 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
-
-    class Config:
-        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[Any] = None
-    icon: Optional[Icon] = None
-    cover: Optional[Cover]
-    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
-
-
-class NotionQueryResponse(BaseModel):
-    """
-    Complete Notion search/query response model that can contain both pages and databases.
-    """
-
-    object: Literal["list"]
-    results: List[Union[NotionPageResponse, NotionDatabaseResponse]]
-    next_cursor: Optional[str] = None
-    has_more: bool
-    type: Literal["page_or_database"]
-    page_or_database: Dict[str, Any]
-    request_id: str
-
-
-# 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
-
-
-# Specific response type for search results (can be mixed)
-class NotionSearchResponse(BaseModel):
-    """
-    Notion search response model that can return both pages and databases.
-    """
-
-    object: Literal["list"]
-    results: List[Union[NotionPageResponse, NotionDatabaseResponse]]
-    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/client.py

@@ -1,11 +1,10 @@
-from typing import Dict, Any, List, Optional
+from typing import Any, 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
+from notionary.database.models import NotionQueryDatabaseResponse
+from notionary.page.models import NotionPageResponse
 
 
-@singleton
 class NotionPageClient(BaseNotionClient):
     """
     Client for Notion page-specific operations.
@@ -22,7 +21,7 @@ class NotionPageClient(BaseNotionClient):
     async def create_page(
         self,
         parent_database_id: Optional[str] = None,
-        properties: Optional[Dict[str, Any]] = None,
+        properties: Optional[dict[str, Any]] = None,
     ) -> NotionPageResponse:
         """
         Creates a new page in a Notion database or as a child page.
@@ -36,7 +35,7 @@ class NotionPageClient(BaseNotionClient):
         return NotionPageResponse.model_validate(response)
 
     async def patch_page(
-        self, page_id: str, data: Optional[Dict[str, Any]] = None
+        self, page_id: str, data: Optional[dict[str, Any]] = None
     ) -> NotionPageResponse:
         """
         Updates a Notion page with the provided data.
@@ -73,7 +72,7 @@ class NotionPageClient(BaseNotionClient):
         return NotionQueryDatabaseResponse.model_validate(result)
 
     async def update_page_properties(
-        self, page_id: str, properties: Dict[str, Any]
+        self, page_id: str, properties: dict[str, Any]
     ) -> NotionPageResponse:
         """
         Updates only the properties of a Notion page.
@@ -95,14 +94,14 @@ class NotionPageClient(BaseNotionClient):
         data = {"archived": False}
         return await self.patch_page(page_id, data)
 
-    async def get_page_blocks(self, page_id: str) -> List[Dict[str, Any]]:
+    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]]:
+    async def get_block_children(self, block_id: str) -> list[dict[str, Any]]:
         """
         Retrieves all children blocks of a specific block.
         """