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

notionary/comments/client.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+from typing import Any, AsyncGenerator, Optional
+
+from notionary.base_notion_client import BaseNotionClient
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+from notionary.comments.models import Comment, CommentListResponse
+
+
+class CommentClient(BaseNotionClient):
+    """
+    Client for Notion comment operations.
+    Uses Pydantic models for typed responses.
+
+    Notes / API constraints:
+    - Listing returns only *unresolved* comments. Resolved comments are not returned.
+    - You can create:
+        1) a top-level comment on a page
+        2) a reply in an existing discussion (requires discussion_id)
+      You cannot start a brand-new inline thread via API.
+    - Read/Insert comment capabilities must be enabled for the integration.
+    """
+
+    async def retrieve_comment(self, comment_id: str) -> Comment:
+        """
+        Retrieve a single Comment object by its ID.
+
+        Requires the integration to have "Read comment" capability enabled.
+        Raises 403 (restricted_resource) without it.
+        """
+        resp = await self.get(f"comments/{comment_id}")
+        if resp is None:
+            raise RuntimeError("Failed to retrieve comment.")
+        return Comment.model_validate(resp)
+
+    async def list_all_comments_for_page(
+        self, *, page_id: str, page_size: int = 100
+    ) -> list[Comment]:
+        """Returns all unresolved comments for a page (handles pagination)."""
+        results: list[Comment] = []
+        cursor: str | None = None
+        while True:
+            page = await self.list_comments(
+                block_id=page_id, start_cursor=cursor, page_size=page_size
+            )
+            results.extend(page.results)
+            if not page.has_more:
+                break
+            cursor = page.next_cursor
+        return results
+
+    async def list_comments(
+        self,
+        *,
+        block_id: str,
+        start_cursor: Optional[str] = None,
+        page_size: Optional[int] = None,
+    ) -> CommentListResponse:
+        """
+        List unresolved comments for a page or block.
+
+        Args:
+            block_id: Page ID or block ID to list comments for.
+            start_cursor: Pagination cursor.
+            page_size: Max items per page (<= 100).
+
+        Returns:
+            CommentListResponse with results, next_cursor, has_more, etc.
+        """
+        params: dict[str, str | int] = {"block_id": block_id}
+        if start_cursor:
+            params["start_cursor"] = start_cursor
+        if page_size:
+            params["page_size"] = page_size
+
+        resp = await self.get("comments", params=params)
+        if resp is None:
+            raise RuntimeError("Failed to list comments.")
+        return CommentListResponse.model_validate(resp)
+
+    async def iter_comments(
+        self,
+        *,
+        block_id: str,
+        page_size: int = 100,
+    ) -> AsyncGenerator[Comment, None]:
+        """
+        Async generator over all unresolved comments for a given page/block.
+        Handles pagination under the hood.
+        """
+        cursor: Optional[str] = None
+        while True:
+            page = await self.list_comments(
+                block_id=block_id, start_cursor=cursor, page_size=page_size
+            )
+            for item in page.results:
+                yield item
+            if not page.has_more:
+                break
+            cursor = page.next_cursor
+
+    async def create_comment_on_page(
+        self,
+        *,
+        page_id: str,
+        text: str,
+        display_name: Optional[dict] = None,
+        attachments: Optional[list[dict]] = None,
+    ) -> Comment:
+        """
+        Create a top-level comment on a page.
+
+        Args:
+            page_id: Target page ID.
+            text: Plain text content for the comment (rich_text will be constructed).
+            display_name: Optional "Comment Display Name" object to override author label.
+            attachments: Optional list of "Comment Attachment" objects (max 3).
+
+        Returns:
+            The created Comment object.
+        """
+        body: dict = {
+            "parent": {"page_id": page_id},
+            "rich_text": [{"type": "text", "text": {"content": text}}],
+        }
+        if display_name:
+            body["display_name"] = display_name
+        if attachments:
+            body["attachments"] = attachments
+
+        resp = await self.post("comments", data=body)
+        if resp is None:
+            raise RuntimeError("Failed to create page comment.")
+        return Comment.model_validate(resp)
+
+    async def create_comment(
+        self,
+        *,
+        page_id: Optional[str] = None,
+        discussion_id: Optional[str] = None,
+        content: Optional[str] = None,
+        rich_text: Optional[list[RichTextObject]] = None,
+        display_name: Optional[dict[str, Any]] = None,
+        attachments: Optional[list[dict[str, Any]]] = None,
+    ) -> Comment:
+        """
+        Create a comment on a page OR reply to an existing discussion.
+
+        Rules:
+        - Exactly one of page_id or discussion_id must be provided.
+        - Provide either rich_text OR content (plain text). If both given, rich_text wins.
+        - Up to 3 attachments allowed by Notion.
+        """
+        # validate parent
+        if (page_id is None) == (discussion_id is None):
+            raise ValueError("Specify exactly one parent: page_id OR discussion_id")
+
+        # build rich_text if only content is provided
+        rt = rich_text if rich_text else None
+        if rt is None:
+            if not content:
+                raise ValueError("Provide either 'rich_text' or 'content'.")
+            rt = [{"type": "text", "text": {"content": content}}]
+
+        body: dict[str, Any] = {"rich_text": rt}
+        if page_id:
+            body["parent"] = {"page_id": page_id}
+        else:
+            body["discussion_id"] = discussion_id
+
+        if display_name:
+            body["display_name"] = display_name
+        if attachments:
+            body["attachments"] = attachments
+
+        resp = await self.post("comments", data=body)
+        if resp is None:
+            raise RuntimeError("Failed to create comment.")
+        return Comment.model_validate(resp)
+
+    # ---------- Convenience wrappers ----------
+
+    async def create_comment_on_page(
+        self,
+        *,
+        page_id: str,
+        text: str,
+        display_name: Optional[dict] = None,
+        attachments: Optional[list[dict]] = None,
+    ) -> Comment:
+        return await self.create_comment(
+            page_id=page_id,
+            content=text,
+            display_name=display_name,
+            attachments=attachments,
+        )
+
+    async def reply_to_discussion(
+        self,
+        *,
+        discussion_id: str,
+        text: str,
+        display_name: Optional[dict] = None,
+        attachments: Optional[list[dict]] = None,
+    ) -> Comment:
+        return await self.create_comment(
+            discussion_id=discussion_id,
+            content=text,
+            display_name=display_name,
+            attachments=attachments,
+        )

notionary/comments/models.py

@@ -0,0 +1,129 @@
+# notionary/comments/models.py
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Literal, Optional, Union
+
+from pydantic import BaseModel, Field, ConfigDict
+
+from notionary.blocks.rich_text import RichTextObject
+
+
+class UserRef(BaseModel):
+    """Minimal Notion user reference."""
+
+    model_config = ConfigDict(extra="ignore")
+    object: Literal["user"] = "user"
+    id: str
+
+
+class CommentParent(BaseModel):
+    """
+    Parent of a comment. Can be page_id or block_id.
+    Notion responds with the active one; the other remains None.
+    """
+
+    model_config = ConfigDict(extra="ignore")
+    type: Literal["page_id", "block_id"]
+    page_id: Optional[str] = None
+    block_id: Optional[str] = None
+
+
+class FileWithExpiry(BaseModel):
+    """File object with temporary URL (common Notion pattern)."""
+
+    model_config = ConfigDict(extra="ignore")
+    url: str
+    expiry_time: Optional[datetime] = None
+
+
+class CommentAttachmentFile(BaseModel):
+    """Attachment stored by Notion with expiring download URL."""
+
+    model_config = ConfigDict(extra="ignore")
+    type: Literal["file"] = "file"
+    name: Optional[str] = None
+    file: FileWithExpiry
+
+
+class CommentAttachmentExternal(BaseModel):
+    """External attachment referenced by URL."""
+
+    model_config = ConfigDict(extra="ignore")
+    type: Literal["external"] = "external"
+    name: Optional[str] = None
+    external: dict  # {"url": "..."} – kept generic
+
+
+CommentAttachment = Union[CommentAttachmentFile, CommentAttachmentExternal]
+
+
+# ---------------------------
+# Display name override (optional)
+# ---------------------------
+
+
+class CommentDisplayName(BaseModel):
+    """
+    Optional display name override for comments created by an integration.
+    Example: {"type": "integration", "resolved_name": "int"}.
+    """
+
+    model_config = ConfigDict(extra="ignore")
+    type: str
+    resolved_name: Optional[str] = None
+
+
+# ---------------------------
+# Core Comment object
+# ---------------------------
+
+
+class Comment(BaseModel):
+    """
+    Notion Comment object as returned by:
+      - GET /v1/comments/{comment_id} (retrieve)
+      - GET /v1/comments?block_id=... (list -> in results[])
+      - POST /v1/comments (create)
+    """
+
+    model_config = ConfigDict(extra="ignore")
+
+    object: Literal["comment"] = "comment"
+    id: str
+
+    parent: CommentParent
+    discussion_id: str
+
+    created_time: datetime
+    last_edited_time: datetime
+
+    created_by: UserRef
+
+    rich_text: list[RichTextObject] = Field(default_factory=list)
+
+    # Optional fields that may appear depending on capabilities/payload
+    display_name: Optional[CommentDisplayName] = None
+    attachments: Optional[list[CommentAttachment]] = None
+
+
+# ---------------------------
+# List envelope (for list-comments)
+# ---------------------------
+
+
+class CommentListResponse(BaseModel):
+    """
+    Envelope for GET /v1/comments?block_id=...
+    """
+
+    model_config = ConfigDict(extra="ignore")
+
+    object: Literal["list"] = "list"
+    results: list[Comment] = Field(default_factory=list)
+    next_cursor: Optional[str] = None
+    has_more: bool = False
+
+    # Notion includes these two fields on the list envelope.
+    type: Optional[Literal["comment"]] = None
+    comment: Optional[dict] = None

notionary/file_upload/client.py

@@ -11,6 +11,7 @@ from notionary.file_upload.models import (
     FileUploadCreateRequest,
     FileUploadListResponse,
     FileUploadResponse,
+    UploadMode,
 )
 
 
@@ -25,7 +26,7 @@ class NotionFileUploadClient(BaseNotionClient):
         filename: str,
         content_type: Optional[str] = None,
         content_length: Optional[int] = None,
-        mode: str = "single_part",
+        mode: UploadMode = UploadMode.SINGLE_PART,
     ) -> Optional[FileUploadResponse]:
         """
         Create a new file upload.
@@ -34,7 +35,7 @@ class NotionFileUploadClient(BaseNotionClient):
             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")
+            mode: Upload mode (UploadMode.SINGLE_PART or UploadMode.MULTI_PART)
 
         Returns:
             FileUploadResponse or None if failed

notionary/file_upload/models.py

@@ -1,8 +1,17 @@
+from enum import Enum
+
 from typing import Literal, Optional
 
 from pydantic import BaseModel
 
 
+class UploadMode(str, Enum):
+    """Enum for file upload modes."""
+
+    SINGLE_PART = "single_part"
+    MULTI_PART = "multi_part"
+
+
 class FileUploadResponse(BaseModel):
     """
     Represents a Notion file upload object as returned by the File Upload API.
@@ -44,7 +53,7 @@ class FileUploadCreateRequest(BaseModel):
     filename: str
     content_type: Optional[str] = None
     content_length: Optional[int] = None
-    mode: Literal["single_part", "multi_part"] = "single_part"
+    mode: UploadMode = UploadMode.SINGLE_PART
 
     def model_dump(self, **kwargs):
         """Override to exclude None values"""

notionary/file_upload/notion_file_upload.py

@@ -5,7 +5,7 @@ from io import BytesIO
 from pathlib import Path
 from typing import Optional
 
-from notionary.file_upload.models import FileUploadResponse
+from notionary.file_upload.models import FileUploadResponse, UploadMode
 from notionary.util import LoggingMixin
 
 
@@ -196,7 +196,7 @@ class NotionFileUpload(LoggingMixin):
             filename=filename,
             content_type=content_type,
             content_length=file_size,
-            mode="single_part",
+            mode=UploadMode.SINGLE_PART,
         )
 
         if not file_upload:
@@ -228,7 +228,7 @@ class NotionFileUpload(LoggingMixin):
             filename=filename,
             content_type=content_type,
             content_length=file_size,
-            mode="multi_part",
+            mode=UploadMode.MULTI_PART,
         )
 
         if not file_upload:
@@ -269,7 +269,7 @@ class NotionFileUpload(LoggingMixin):
             filename=filename,
             content_type=content_type,
             content_length=file_size,
-            mode="single_part",
+            mode=UploadMode.SINGLE_PART,
         )
 
         if not file_upload:
@@ -299,7 +299,7 @@ class NotionFileUpload(LoggingMixin):
             filename=filename,
             content_type=content_type,
             content_length=file_size,
-            mode="multi_part",
+            mode=UploadMode.MULTI_PART,
         )
 
         if not file_upload:

notionary/page/client.py

@@ -42,18 +42,13 @@ class NotionPageClient(BaseNotionClient):
         )
 
         properties: dict[str, Any] = {
-            "title": {
-                "title": [
-                    {"type": "text", "text": {"content": title}}
-                ]
-            }
+            "title": {"title": [{"type": "text", "text": {"content": title}}]}
         }
 
         payload = {"parent": parent, "properties": properties}
         response = await self.post("pages", payload)
         return NotionPageResponse.model_validate(response)
 
-
     async def patch_page(
         self, page_id: str, data: Optional[dict[str, Any]] = None
     ) -> NotionPageResponse:

notionary/page/markdown_whitespace_processor.py

@@ -0,0 +1,129 @@
+"""
+Markdown whitespace processing utilities.
+
+Handles normalization of markdown text while preserving code blocks and their indentation.
+"""
+
+from typing import Tuple
+
+
+class MarkdownWhitespaceProcessor:
+    """
+    Processes markdown text to normalize whitespace while preserving code block formatting.
+
+    This processor handles:
+    - Removing leading whitespace from regular lines
+    - Preserving code block structure and indentation
+    - Normalizing code block markers
+    """
+
+    @staticmethod
+    def process_markdown_whitespace(markdown_text: str) -> str:
+        """Process markdown text to normalize whitespace while preserving code blocks."""
+        lines = markdown_text.split("\n")
+        if not lines:
+            return ""
+
+        return MarkdownWhitespaceProcessor._process_whitespace_lines(lines)
+
+    @staticmethod
+    def _process_whitespace_lines(lines: list[str]) -> str:
+        """Process all lines and return the processed markdown."""
+        processed_lines = []
+        in_code_block = False
+        current_code_block = []
+
+        for line in lines:
+            processed_lines, in_code_block, current_code_block = (
+                MarkdownWhitespaceProcessor._process_single_line(
+                    line, processed_lines, in_code_block, current_code_block
+                )
+            )
+
+        return "\n".join(processed_lines)
+
+    @staticmethod
+    def _process_single_line(
+        line: str,
+        processed_lines: list[str],
+        in_code_block: bool,
+        current_code_block: list[str],
+    ) -> Tuple[list[str], bool, list[str]]:
+        """Process a single line and return updated state."""
+        if MarkdownWhitespaceProcessor._is_code_block_marker(line):
+            return MarkdownWhitespaceProcessor._handle_code_block_marker(
+                line, processed_lines, in_code_block, current_code_block
+            )
+        if in_code_block:
+            current_code_block.append(line)
+            return processed_lines, in_code_block, current_code_block
+        else:
+            processed_lines.append(line.lstrip())
+            return processed_lines, in_code_block, current_code_block
+
+    @staticmethod
+    def _handle_code_block_marker(
+        line: str,
+        processed_lines: list[str],
+        in_code_block: bool,
+        current_code_block: list[str],
+    ) -> Tuple[list[str], bool, list[str]]:
+        """Handle code block start/end markers."""
+        if not in_code_block:
+            return MarkdownWhitespaceProcessor._start_code_block(line, processed_lines)
+        else:
+            return MarkdownWhitespaceProcessor._end_code_block(
+                processed_lines, current_code_block
+            )
+
+    @staticmethod
+    def _start_code_block(
+        line: str, processed_lines: list[str]
+    ) -> Tuple[list[str], bool, list[str]]:
+        """Start a new code block."""
+        processed_lines.append(
+            MarkdownWhitespaceProcessor._normalize_code_block_start(line)
+        )
+        return processed_lines, True, []
+
+    @staticmethod
+    def _end_code_block(
+        processed_lines: list[str], current_code_block: list[str]
+    ) -> Tuple[list[str], bool, list[str]]:
+        """End the current code block."""
+        processed_lines.extend(
+            MarkdownWhitespaceProcessor._normalize_code_block_content(
+                current_code_block
+            )
+        )
+        processed_lines.append("```")
+        return processed_lines, False, []
+
+    @staticmethod
+    def _is_code_block_marker(line: str) -> bool:
+        """Check if line is a code block marker."""
+        return line.lstrip().startswith("```")
+
+    @staticmethod
+    def _normalize_code_block_start(line: str) -> str:
+        """Normalize code block opening marker."""
+        language = line.lstrip().replace("```", "", 1).strip()
+        return "```" + language
+
+    @staticmethod
+    def _normalize_code_block_content(code_lines: list[str]) -> list[str]:
+        """Normalize code block indentation."""
+        if not code_lines:
+            return []
+
+        # Find minimum indentation from non-empty lines
+        non_empty_lines = [line for line in code_lines if line.strip()]
+        if not non_empty_lines:
+            return [""] * len(code_lines)
+
+        min_indent = min(len(line) - len(line.lstrip()) for line in non_empty_lines)
+        if min_indent == 0:
+            return code_lines
+
+        # Remove common indentation
+        return ["" if not line.strip() else line[min_indent:] for line in code_lines]