notionary 0.2.26__py3-none-any.whl → 0.2.28__py3-none-any.whl

notionary/__init__.py

@@ -1,22 +1,7 @@
-from notionary.blocks import bootstrap_blocks
-
-bootstrap_blocks()
-
-from .database import DatabaseFilterBuilder, NotionDatabase
-from .file_upload import NotionFileUpload
-from .blocks.markdown.markdown_builder import MarkdownBuilder
-from .page.notion_page import NotionPage
-from .user import NotionBotUser, NotionUser, NotionUserManager
+from .data_source.service import NotionDataSource
+from .database.service import NotionDatabase
+from .page.content.markdown.builder import MarkdownBuilder
+from .page.service import NotionPage
 from .workspace import NotionWorkspace
 
-__all__ = [
-    "NotionDatabase",
-    "DatabaseFilterBuilder",
-    "NotionPage",
-    "NotionWorkspace",
-    "NotionUser",
-    "NotionUserManager",
-    "NotionBotUser",
-    "NotionFileUpload",
-    "MarkdownBuilder",
-]
+__all__ = ["MarkdownBuilder", "NotionDataSource", "NotionDatabase", "NotionPage", "NotionWorkspace", "NotionWorkspace"]

notionary/blocks/client.py

@@ -1,65 +1,42 @@
-from typing import Any, Optional
+from typing import Any
 
-from notionary.base_notion_client import BaseNotionClient
-from notionary.blocks.models import Block, BlockChildrenResponse, BlockCreateRequest
+from notionary.blocks.schemas import Block, BlockChildrenResponse, BlockCreatePayload
+from notionary.http.client import NotionHttpClient
+from notionary.utils.pagination import paginate_notion_api
 
 
-class NotionBlockClient(BaseNotionClient):
-    """
-    Client for Notion Block API operations.
-    """
-
-    async def get_block(self, block_id: str) -> Optional[Block]:
-        """
-        Retrieves a single block by its ID.
-        """
-        self.logger.debug("Retrieving block: %s", block_id)
+class NotionBlockHttpClient(NotionHttpClient):
+    BATCH_SIZE = 100
 
+    async def get_block(self, block_id: str) -> Block:
         response = await self.get(f"blocks/{block_id}")
-        if response:
-            try:
-                return Block.model_validate(response)
-            except Exception as e:
-                self.logger.error("Failed to parse block response: %s", str(e))
-                return None
-        return None
-
-    async def get_blocks_by_page_id_recursively(
-        self, page_id: str, parent_id: Optional[str] = None
-    ) -> list[Block]:
-        response = (
-            await self.get_block_children(block_id=page_id)
-            if parent_id is None
-            else await self.get_block_children(block_id=parent_id)
-        )
+        return Block.model_validate(response)
 
-        if not response or not response.results:
-            return []
+    async def delete_block(self, block_id: str) -> None:
+        self.logger.debug("Deleting block: %s", block_id)
+        await self.delete(f"blocks/{block_id}")
 
-        blocks = response.results
+    async def get_block_tree(self, parent_block_id: str) -> list[Block]:
+        blocks_at_this_level = await self.get_all_block_children(parent_block_id)
 
-        for block in blocks:
-            if not block.has_children:
-                continue
+        for block in blocks_at_this_level:
+            if block.has_children:
+                nested_children = await self.get_block_tree(parent_block_id=block.id)
+                block.children = nested_children
 
-            block_id = block.id
-            if not block_id:
-                continue
+        return blocks_at_this_level
 
-            children = await self.get_blocks_by_page_id_recursively(
-                page_id=page_id, parent_id=block_id
-            )
-            if children:
-                block.children = children
+    async def get_all_block_children(self, parent_block_id: str) -> list[Block]:
+        self.logger.debug("Retrieving all children for block: %s", parent_block_id)
 
-        return blocks
+        all_blocks = await paginate_notion_api(self.get_block_children, block_id=parent_block_id)
+
+        self.logger.debug("Retrieved %d total children for block %s", len(all_blocks), parent_block_id)
+        return all_blocks
 
     async def get_block_children(
-        self, block_id: str, start_cursor: Optional[str] = None, page_size: int = 100
-    ) -> Optional[BlockChildrenResponse]:
-        """
-        Retrieves the children of a block with pagination support.
-        """
+        self, block_id: str, start_cursor: str | None = None, page_size: int = 100
+    ) -> BlockChildrenResponse:
         self.logger.debug("Retrieving children of block: %s", block_id)
 
         params = {"page_size": min(page_size, 100)}
@@ -67,190 +44,85 @@ class NotionBlockClient(BaseNotionClient):
             params["start_cursor"] = start_cursor
 
         response = await self.get(f"blocks/{block_id}/children", params=params)
+        return BlockChildrenResponse.model_validate(response)
 
-        if not response:
+    async def append_block_children(
+        self,
+        block_id: str,
+        children: list[BlockCreatePayload],
+        insert_after_block_id: str | None = None,
+    ) -> BlockChildrenResponse | None:
+        if not children:
+            self.logger.warning("No children provided to append")
             return None
 
-        try:
-            return BlockChildrenResponse.model_validate(response)
-        except Exception as e:
-            self.logger.error("Failed to parse block children response: %s", str(e))
-            return None
+        self.logger.debug("Appending %d children to block: %s", len(children), block_id)
 
-    async def get_all_block_children(self, block_id: str) -> list[Block]:
-        """
-        Retrieves ALL children of a block, handling pagination automatically.
-        """
-        all_blocks = []
-        cursor = None
+        batches = self._split_into_batches(children)
 
-        while True:
-            response = await self.get_block_children(
-                block_id=block_id, start_cursor=cursor, page_size=100
-            )
+        if len(batches) == 1:
+            children_dicts = self._serialize_blocks(batches[0])
+            return await self._send_append_request(block_id, children_dicts, insert_after_block_id)
 
-            if not response:
-                break
+        return await self._send_batched_append_requests(block_id, batches, insert_after_block_id)
 
-            all_blocks.extend(response.results)
+    def _split_into_batches(self, blocks: list[BlockCreatePayload]) -> list[list[BlockCreatePayload]]:
+        batches = []
+        for i in range(0, len(blocks), self.BATCH_SIZE):
+            batch = blocks[i : i + self.BATCH_SIZE]
+            batches.append(batch)
+        return batches
 
-            if not response.has_more:
-                break
+    def _serialize_blocks(self, blocks: list[BlockCreatePayload]) -> list[dict[str, Any]]:
+        return [block.model_dump(exclude_none=True) for block in blocks]
 
-            cursor = response.next_cursor
+    async def _send_append_request(
+        self, block_id: str, children: list[dict[str, Any]], after_block_id: str | None = None
+    ) -> BlockChildrenResponse:
+        payload = {"children": children}
+        if after_block_id:
+            payload["after"] = after_block_id
 
-        self.logger.debug(
-            "Retrieved %d total children for block %s", len(all_blocks), block_id
-        )
-        return all_blocks
+        response = await self.patch(f"blocks/{block_id}/children", payload)
+        return BlockChildrenResponse.model_validate(response)
 
-    async def append_block_children(
-        self,
-        block_id: str,
-        children: list[BlockCreateRequest],
-        after: Optional[str] = None,
-    ) -> Optional[BlockChildrenResponse]:
-        """
-        Appends new child blocks to a parent block.
-        Automatically handles batching for more than 100 blocks.
-        """
-        if not children:
-            self.logger.warning("No children provided to append")
-            return None
+    async def _send_batched_append_requests(
+        self, block_id: str, batches: list[list[BlockCreatePayload]], initial_after_block_id: str | None = None
+    ) -> BlockChildrenResponse:
+        total_blocks = sum(len(batch) for batch in batches)
+        self.logger.info("Appending %d blocks in %d batches", total_blocks, len(batches))
 
-        self.logger.debug("Appending %d children to block: %s", len(children), block_id)
+        all_responses = []
+        after_block_id = initial_after_block_id
 
-        # Convert Pydantic models to dictionaries for API
-        children_dicts = [block.model_dump(exclude_none=True) for block in children]
-
-        # If 100 or fewer blocks, use single request
-        if len(children_dicts) <= 100:
-            return await self._append_single_batch(block_id, children_dicts, after)
-
-        # For more than 100 blocks, use batch processing
-        return await self._append_multiple_batches(block_id, children_dicts, after)
-
-    async def _append_single_batch(
-        self, block_id: str, children: list[dict[str, Any]], after: Optional[str] = None
-    ) -> Optional[BlockChildrenResponse]:
-        """
-        Appends a single batch of blocks (≤100).
-        """
-        data = {"children": children}
-        if after:
-            data["after"] = after
-
-        response = await self.patch(f"blocks/{block_id}/children", data)
-        if response:
-            try:
-                return BlockChildrenResponse.model_validate(response)
-            except Exception as e:
-                self.logger.error("Failed to parse append response: %s", str(e))
-                return None
-        return None
-
-    async def _append_multiple_batches(
-        self, block_id: str, children: list[dict[str, Any]], after: Optional[str] = None
-    ) -> Optional[BlockChildrenResponse]:
-        """
-        Appends multiple batches of blocks, handling pagination.
-        """
-        all_results = []
-        current_after = after
-        batch_size = 100
-
-        self.logger.info(
-            "Processing %d blocks in batches of %d", len(children), batch_size
-        )
+        for batch_index, batch in enumerate(batches, start=1):
+            self.logger.debug("Processing batch %d/%d (%d blocks)", batch_index, len(batches), len(batch))
 
-        # Process blocks in chunks of 100
-        for i in range(0, len(children), batch_size):
-            batch = children[i : i + batch_size]
-            batch_num = (i // batch_size) + 1
-            total_batches = (len(children) + batch_size - 1) // batch_size
-
-            self.logger.debug(
-                "Processing batch %d/%d (%d blocks)",
-                batch_num,
-                total_batches,
-                len(batch),
-            )
-
-            # Append current batch
-            response = await self._append_single_batch(block_id, batch, current_after)
-
-            if not response:
-                self.logger.error(
-                    "Failed to append batch %d/%d", batch_num, total_batches
-                )
-                # Return partial results if we have any
-                if all_results:
-                    return self._combine_batch_responses(all_results)
-                return None
-
-            all_results.append(response)
-
-            # Update 'after' to the last block ID from this batch for next iteration
-            if response.results:
-                current_after = response.results[-1].id
+            children_dicts = self._serialize_blocks(batch)
+            response = await self._send_append_request(block_id, children_dicts, after_block_id)
+            all_responses.append(response)
 
-            self.logger.debug(
-                "Successfully appended batch %d/%d", batch_num, total_batches
-            )
+            if response.results:
+                after_block_id = response.results[-1].id
 
-        self.logger.info(
-            "Successfully appended all %d blocks in %d batches",
-            len(children),
-            len(all_results),
-        )
+            self.logger.debug("Completed batch %d/%d", batch_index, len(batches))
 
-        # Combine all batch responses into a single response
-        return self._combine_batch_responses(all_results)
+        self.logger.info("Successfully appended all blocks in %d batches", len(batches))
+        return self._merge_responses(all_responses)
 
-    def _combine_batch_responses(
-        self, responses: list[BlockChildrenResponse]
-    ) -> BlockChildrenResponse:
-        """
-        Combines multiple batch responses into a single response.
-        """
+    def _merge_responses(self, responses: list[BlockChildrenResponse]) -> BlockChildrenResponse:
         if not responses:
-            # Return empty response structure
-            return BlockChildrenResponse(
-                object="list",
-                results=[],
-                next_cursor=None,
-                has_more=False,
-                type="block",
-                block={},
-                request_id="",
-            )
-
-        # Use the first response as template and combine all results
-        combined = responses[0]
-        all_blocks = []
-
-        for response in responses:
-            all_blocks.extend(response.results)
-
-        # Create new combined response
-        return BlockChildrenResponse(
-            object=combined.object,
-            results=all_blocks,
-            next_cursor=None,  # No pagination in combined result
-            has_more=False,  # All blocks are included
-            type=combined.type,
-            block=combined.block,
-            request_id=responses[-1].request_id,  # Use last request ID
-        )
+            raise ValueError("Cannot merge empty response list - this should never happen")
 
-    async def delete_block(self, block_id: str) -> Optional[Block]:
-        """
-        Deletes (archives) a block.
-        """
-        self.logger.debug("Deleting block: %s", block_id)
+        first_response = responses[0]
+        all_results = [block for response in responses for block in response.results]
 
-        success = await self.delete(f"blocks/{block_id}")
-        if success:
-            # After deletion, retrieve the block to return the updated state
-            return await self.get_block(block_id)
-        return None
+        return BlockChildrenResponse(
+            object=first_response.object,
+            results=all_results,
+            next_cursor=None,
+            has_more=False,
+            type=first_response.type,
+            block=first_response.block,
+            request_id=responses[-1].request_id,
+        )

notionary/blocks/enums.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import Self
+
+
+class BlockColor(StrEnum):
+    BLUE = "blue"
+    BLUE_BACKGROUND = "blue_background"
+    BROWN = "brown"
+    BROWN_BACKGROUND = "brown_background"
+    DEFAULT = "default"
+    GRAY = "gray"
+    GRAY_BACKGROUND = "gray_background"
+    GREEN = "green"
+    GREEN_BACKGROUND = "green_background"
+    ORANGE = "orange"
+    ORANGE_BACKGROUND = "orange_background"
+    YELLOW = "yellow"
+    YELLOW_BACKGROUND = "yellow_background"
+    PINK = "pink"
+    PINK_BACKGROUND = "pink_background"
+    PURPLE = "purple"
+    PURPLE_BACKGROUND = "purple_background"
+    RED = "red"
+    RED_BACKGROUND = "red_background"
+    DEFAULT_BACKGROUND = "default_background"
+
+
+class BlockType(StrEnum):
+    AUDIO = "audio"
+    BOOKMARK = "bookmark"
+    BREADCRUMB = "breadcrumb"
+    BULLETED_LIST_ITEM = "bulleted_list_item"
+    CALLOUT = "callout"
+    CHILD_DATABASE = "child_database"
+    CHILD_PAGE = "child_page"
+    CODE = "code"
+    COLUMN = "column"
+    COLUMN_LIST = "column_list"
+    DIVIDER = "divider"
+    EMBED = "embed"
+    EQUATION = "equation"
+    FILE = "file"
+    HEADING_1 = "heading_1"
+    HEADING_2 = "heading_2"
+    HEADING_3 = "heading_3"
+    IMAGE = "image"
+    LINK_PREVIEW = "link_preview"
+    LINK_TO_PAGE = "link_to_page"
+    NUMBERED_LIST_ITEM = "numbered_list_item"
+    PARAGRAPH = "paragraph"
+    PDF = "pdf"
+    QUOTE = "quote"
+    SYNCED_BLOCK = "synced_block"
+    TABLE = "table"
+    TABLE_OF_CONTENTS = "table_of_contents"
+    TABLE_ROW = "table_row"
+    TO_DO = "to_do"
+    TOGGLE = "toggle"
+    UNSUPPORTED = "unsupported"
+    VIDEO = "video"
+
+
+class FileType(StrEnum):
+    EXTERNAL = "external"
+    FILE = "file"
+    FILE_UPLOAD = "file_upload"
+
+
+class CodeLanguage(StrEnum):
+    ABAP = "abap"
+    ARDUINO = "arduino"
+    BASH = "bash"
+    BASIC = "basic"
+    C = "c"
+    CLOJURE = "clojure"
+    COFFEESCRIPT = "coffeescript"
+    CPP = "c++"
+    CSHARP = "c#"
+    CSS = "css"
+    DART = "dart"
+    DIFF = "diff"
+    DOCKER = "docker"
+    ELIXIR = "elixir"
+    ELM = "elm"
+    ERLANG = "erlang"
+    FLOW = "flow"
+    FORTRAN = "fortran"
+    FSHARP = "f#"
+    GHERKIN = "gherkin"
+    GLSL = "glsl"
+    GO = "go"
+    GRAPHQL = "graphql"
+    GROOVY = "groovy"
+    HASKELL = "haskell"
+    HTML = "html"
+    JAVA = "java"
+    JAVASCRIPT = "javascript"
+    JSON = "json"
+    JULIA = "julia"
+    KOTLIN = "kotlin"
+    LATEX = "latex"
+    LESS = "less"
+    LISP = "lisp"
+    LIVESCRIPT = "livescript"
+    LUA = "lua"
+    MAKEFILE = "makefile"
+    MARKDOWN = "markdown"
+    MARKUP = "markup"
+    MATLAB = "matlab"
+    MERMAID = "mermaid"
+    NIX = "nix"
+    OBJECTIVE_C = "objective-c"
+    OCAML = "ocaml"
+    PASCAL = "pascal"
+    PERL = "perl"
+    PHP = "php"
+    PLAIN_TEXT = "plain text"
+    POWERSHELL = "powershell"
+    PROLOG = "prolog"
+    PROTOBUF = "protobuf"
+    PYTHON = "python"
+    R = "r"
+    REASON = "reason"
+    RUBY = "ruby"
+    RUST = "rust"
+    SASS = "sass"
+    SCALA = "scala"
+    SCHEME = "scheme"
+    SCSS = "scss"
+    SHELL = "shell"
+    SQL = "sql"
+    SWIFT = "swift"
+    TYPESCRIPT = "typescript"
+    VB_NET = "vb.net"
+    VERILOG = "verilog"
+    VHDL = "vhdl"
+    VISUAL_BASIC = "visual basic"
+    WEBASSEMBLY = "webassembly"
+    XML = "xml"
+    YAML = "yaml"
+    JAVA_C_CPP_CSHARP = "java/c/c++/c#"
+
+    @classmethod
+    def from_string(cls, lang_str: str | None, default: Self | None = None) -> Self:
+        if not lang_str:
+            return default if default is not None else cls.PLAIN_TEXT
+
+        normalized = lang_str.lower().strip()
+
+        aliases = {
+            "cpp": cls.CPP,
+            "c++": cls.CPP,
+            "js": cls.JAVASCRIPT,
+            "py": cls.PYTHON,
+            "ts": cls.TYPESCRIPT,
+        }
+
+        if normalized in aliases:
+            return aliases[normalized]
+
+        for member in cls:
+            if member.value.lower() == normalized:
+                return member
+
+        return default if default is not None else cls.PLAIN_TEXT