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

notionary/blocks/{shared/block_client.py → client.py}

@@ -1,10 +1,9 @@
-from typing import Optional, Dict, Any
+from typing import Any, Optional
+
 from notionary.base_notion_client import BaseNotionClient
-from notionary.util import singleton
-from notionary.blocks.shared.models import Block, BlockChildrenResponse
+from notionary.blocks.models import Block, BlockChildrenResponse, BlockCreateRequest
 
 
-@singleton
 class NotionBlockClient(BaseNotionClient):
     """
     Client for Notion Block API operations.
@@ -25,6 +24,36 @@ class NotionBlockClient(BaseNotionClient):
                 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)
+        )
+
+        if not response or not response.results:
+            return []
+
+        blocks = response.results
+
+        for block in blocks:
+            if not block.has_children:
+                continue
+
+            block_id = block.id
+            if not block_id:
+                continue
+
+            children = await self.get_blocks_by_page_id_recursively(
+                page_id=page_id, parent_id=block_id
+            )
+            if children:
+                block.children = children
+
+        return blocks
+
     async def get_block_children(
         self, block_id: str, start_cursor: Optional[str] = None, page_size: int = 100
     ) -> Optional[BlockChildrenResponse]:
@@ -38,13 +67,15 @@ class NotionBlockClient(BaseNotionClient):
             params["start_cursor"] = start_cursor
 
         response = await self.get(f"blocks/{block_id}/children", params=params)
-        if response:
-            try:
-                return BlockChildrenResponse.model_validate(response)
-            except Exception as e:
-                self.logger.error("Failed to parse block children response: %s", str(e))
-                return None
-        return None
+
+        if not response:
+            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
 
     async def get_all_block_children(self, block_id: str) -> list[Block]:
         """
@@ -74,7 +105,10 @@ class NotionBlockClient(BaseNotionClient):
         return all_blocks
 
     async def append_block_children(
-        self, block_id: str, children: list[Dict[str, Any]], after: Optional[str] = None
+        self,
+        block_id: str,
+        children: list[BlockCreateRequest],
+        after: Optional[str] = None,
     ) -> Optional[BlockChildrenResponse]:
         """
         Appends new child blocks to a parent block.
@@ -86,15 +120,18 @@ class NotionBlockClient(BaseNotionClient):
 
         self.logger.debug("Appending %d children to block: %s", len(children), 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) <= 100:
-            return await self._append_single_batch(block_id, children, after)
+        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, after)
+        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
+        self, block_id: str, children: list[dict[str, Any]], after: Optional[str] = None
     ) -> Optional[BlockChildrenResponse]:
         """
         Appends a single batch of blocks (≤100).
@@ -113,7 +150,7 @@ class NotionBlockClient(BaseNotionClient):
         return None
 
     async def _append_multiple_batches(
-        self, block_id: str, children: list[Dict[str, Any]], after: Optional[str] = None
+        self, block_id: str, children: list[dict[str, Any]], after: Optional[str] = None
     ) -> Optional[BlockChildrenResponse]:
         """
         Appends multiple batches of blocks, handling pagination.
@@ -206,27 +243,6 @@ class NotionBlockClient(BaseNotionClient):
             request_id=responses[-1].request_id,  # Use last request ID
         )
 
-    async def update_block(
-        self, block_id: str, block_data: Dict[str, Any], archived: Optional[bool] = None
-    ) -> Optional[Block]:
-        """
-        Updates an existing block.
-        """
-        self.logger.debug("Updating block: %s", block_id)
-
-        data = block_data.copy()
-        if archived is not None:
-            data["archived"] = archived
-
-        response = await self.patch(f"blocks/{block_id}", data)
-        if response:
-            try:
-                return Block.model_validate(response)
-            except Exception as e:
-                self.logger.error("Failed to parse update response: %s", str(e))
-                return None
-        return None
-
     async def delete_block(self, block_id: str) -> Optional[Block]:
         """
         Deletes (archives) a block.
@@ -238,19 +254,3 @@ class NotionBlockClient(BaseNotionClient):
             # After deletion, retrieve the block to return the updated state
             return await self.get_block(block_id)
         return None
-
-    async def archive_block(self, block_id: str) -> Optional[Block]:
-        """
-        Archives a block by setting archived=True.
-        """
-        self.logger.debug("Archiving block: %s", block_id)
-
-        return await self.update_block(block_id=block_id, block_data={}, archived=True)
-
-    async def unarchive_block(self, block_id: str) -> Optional[Block]:
-        """
-        Unarchives a block by setting archived=False.
-        """
-        self.logger.debug("Unarchiving block: %s", block_id)
-
-        return await self.update_block(block_id=block_id, block_data={}, archived=False)

notionary/blocks/code/__init__.py

@@ -1,7 +1,11 @@
-from .code_element import CodeElement
-from .code_markdown_node import CodeMarkdownNode
+from notionary.blocks.code.code_element import CodeElement
+from notionary.blocks.code.code_markdown_node import CodeMarkdownNode
+from notionary.blocks.code.code_models import CodeBlock, CodeLanguage, CreateCodeBlock
 
 __all__ = [
     "CodeElement",
+    "CodeBlock",
+    "CodeLanguage",
+    "CreateCodeBlock",
     "CodeMarkdownNode",
 ]

notionary/blocks/code/code_element.py

@@ -1,117 +1,108 @@
+from __future__ import annotations
+
 import re
+from typing import Optional
 
-from typing import Optional, Any
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import (
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
-)
-from notionary.blocks.shared.models import RichTextObject
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.code.code_models import CodeBlock, CodeLanguage, CreateCodeBlock
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
+from notionary.blocks.models import Block, BlockCreateResult, BlockType
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
 
 
-class CodeElement(NotionBlockElement):
+class CodeElement(BaseBlockElement):
     """
     Handles conversion between Markdown code blocks and Notion code blocks.
+    Now integrated into the LineProcessor stack system.
 
     Markdown code block syntax:
     ```language
-    code content
+    [code content as child lines]
     ```
-    Caption: optional caption text
-
-    Where:
-    - language is optional and specifies the programming language
-    - code content is the code to be displayed
-    - Caption line is optional and must appear immediately after the closing ```
     """
 
-    PATTERN = re.compile(
-        r"```(\w*)\n([\s\S]+?)```(?:\n(?:Caption|caption):\s*(.+))?", re.MULTILINE
-    )
+    DEFAULT_LANGUAGE = "plain text"
+    CODE_START_PATTERN = re.compile(r"^```(\w*)\s*$")
+    CODE_START_WITH_CAPTION_PATTERN = re.compile(r"^```(\w*)\s*(?:\"([^\"]*)\")?\s*$")
 
     @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if text contains a markdown code block."""
-        return bool(cls.PATTERN.search(text))
+    def match_notion(cls, block: Block) -> bool:
+        """Check if block is a Notion code block."""
+        return block.type == BlockType.CODE and block.code
 
     @classmethod
-    def match_notion(cls, block: dict[str, any]) -> bool:
-        """Check if block is a Notion code block."""
-        return block.get("type") == "code"
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """Convert opening ```language to Notion code block."""
+        if not (match := cls.CODE_START_PATTERN.match(text.strip())):
+            return None
+
+        language = (match.group(1) or cls.DEFAULT_LANGUAGE).lower()
+        language = cls._normalize_language(language)
+
+        # Create empty CodeBlock - content will be added by stack processor
+        code_block = CodeBlock(rich_text=[], language=language, caption=[])
+        return CreateCodeBlock(code=code_block)
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown code block to Notion code block."""
-        match = cls.PATTERN.search(text)
+    def create_from_markdown_block(
+        cls, opening_line: str, code_lines: list[str]
+    ) -> BlockCreateResult:
+        """
+        Create a complete code block from markdown components.
+        """
+        match = cls.CODE_START_WITH_CAPTION_PATTERN.match(opening_line.strip())
         if not match:
             return None
 
-        language = match.group(1) or "plain text"
-        content = match.group(2)
-        caption = match.group(3)
+        language = (match.group(1) or cls.DEFAULT_LANGUAGE).lower()
+        language = cls._normalize_language(language)
 
-        if content.endswith("\n"):
-            content = content[:-1]
+        caption = match.group(2) if match.group(2) else None
 
-        # Create code block with rich text
-        content_rich_text = RichTextObject.from_plain_text(content)
+        # Create rich text content from code lines
+        rich_text = []
+        if code_lines:
+            content = "\n".join(code_lines)
+            rich_text = [RichTextObject.for_code_block(content)]
 
-        block = {
-            "type": "code",
-            "code": {
-                "rich_text": [content_rich_text.model_dump()],
-                "language": language,
-            },
-        }
+        caption_list = []
+        if caption:
+            caption_list = [RichTextObject.for_caption(caption)]
 
-        # Add caption if provided
-        if caption and caption.strip():
-            caption_rich_text = RichTextObject.from_plain_text(caption.strip())
-            block["code"]["caption"] = [caption_rich_text.model_dump()]
-
-        # Leerer Paragraph nach dem Code-Block
-        empty_paragraph = {"type": "paragraph", "paragraph": {"rich_text": []}}
+        code_block = CodeBlock(
+            rich_text=rich_text, language=language, caption=caption_list
+        )
 
-        return [block, empty_paragraph]
+        return CreateCodeBlock(code=code_block)
 
     @classmethod
-    def notion_to_markdown(cls, block: dict[str, Any]) -> Optional[str]:
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
         """Convert Notion code block to Markdown."""
-        if block.get("type") != "code":
+        if block.type != BlockType.CODE:
             return None
 
-        code_data = block.get("code", {})
-        language = code_data.get("language", "")
-        rich_text = code_data.get("rich_text", [])
-        caption = code_data.get("caption", [])
-
-        def extract_content(rich_text_list):
-            """Extract code content from rich_text array."""
-            return "".join(
-                text.get("text", {}).get("content", "")
-                if text.get("type") == "text"
-                else text.get("plain_text", "")
-                for text in rich_text_list
-            )
-
-        def extract_caption(caption_list):
-            """Extract caption text from caption array."""
-            return "".join(
-                c.get("text", {}).get("content", "")
-                for c in caption_list
-                if c.get("type") == "text"
-            )
-
-        code_content = extract_content(rich_text)
-        caption_text = extract_caption(caption)
+        if not block.code:
+            return None
+
+        language_enum = block.code.language
+        rich_text = block.code.rich_text or []
+        caption = block.code.caption or []
+
+        code_content = cls.extract_content(rich_text)
+        caption_text = cls.extract_caption(caption)
+
+        # Convert enum to string value
+        language = language_enum.value if language_enum else ""
 
         # Handle language - convert "plain text" back to empty string for markdown
-        if language == "plain text":
+        if language == cls.DEFAULT_LANGUAGE:
             language = ""
 
         # Build markdown code block
-        result = f"```{language}\n{code_content}\n```" if language else f"```\n{code_content}\n```"
+        if language:
+            result = f"```{language}\n{code_content}\n```"
+        else:
+            result = f"```\n{code_content}\n```"
 
         # Add caption if present
         if caption_text:
@@ -120,115 +111,39 @@ class CodeElement(NotionBlockElement):
         return result
 
     @classmethod
-    def find_matches(cls, text: str) -> list[tuple[int, int, dict[str, any]]]:
+    def _normalize_language(cls, language: str) -> CodeLanguage:
         """
-        Find all code block matches in the text and return their positions.
-
-        Args:
-            text: The text to search in
-
-        Returns:
-            List of tuples with (start_pos, end_pos, block)
+        Normalize the language string to a valid CodeLanguage enum or default.
         """
-        matches = []
-        for match in CodeElement.PATTERN.finditer(text):
-            language = match.group(1) or "plain text"
-            content = match.group(2)
-            caption = match.group(3)
-
-            # Remove trailing newline if present
-            if content.endswith("\n"):
-                content = content[:-1]
-
-            block = {
-                "type": "code",
-                "code": {
-                    "rich_text": [
-                        {
-                            "type": "text",
-                            "text": {"content": content},
-                            "plain_text": content,
-                        }
-                    ],
-                    "language": language,
-                },
-            }
-
-            # Add caption if provided
-            if caption and caption.strip():
-                block["code"]["caption"] = [
-                    {
-                        "type": "text",
-                        "text": {"content": caption.strip()},
-                        "plain_text": caption.strip(),
-                    }
-                ]
-
-            matches.append((match.start(), match.end(), block))
-
-        return matches
+        # Try to find matching enum by value
+        for lang_enum in CodeLanguage:
+            if lang_enum.value.lower() == language.lower():
+                return lang_enum
 
-    @classmethod
-    def is_multiline(cls) -> bool:
-        return True
-
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the code block element.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Use fenced code blocks to format content as code. Supports language annotations like "
-                "'python', 'json', or 'mermaid'. Useful for displaying code, configurations, command-line "
-                "examples, or diagram syntax. Also suitable for explaining or visualizing systems with diagram languages. "
-                "Code blocks can include optional captions for better documentation."
-            )
-            .with_usage_guidelines(
-                "Use code blocks when you want to present technical content like code snippets, terminal commands, "
-                "JSON structures, or system diagrams. Especially helpful when structure and formatting are essential. "
-                "Add captions to provide context, explanations, or titles for your code blocks."
-            )
-            .with_syntax(
-                "```language\ncode content\n```\nCaption: optional caption text\n\n"
-                "OR\n\n"
-                "```language\ncode content\n```"
-            )
-            .with_examples(
-                [
-                    "```python\nprint('Hello, world!')\n```\nCaption: Basic Python greeting example",
-                    '```json\n{"name": "Alice", "age": 30}\n```\nCaption: User data structure',
-                    "```mermaid\nflowchart TD\n  A --> B\n```\nCaption: Simple flow diagram",
-                    '```bash\ngit commit -m "Initial commit"\n```',
-                ]
-            )
-            .with_avoidance_guidelines(
-                "NEVER EVER wrap markdown content with ```markdown. Markdown should be written directly without code block formatting. "
-                "NEVER use ```markdown under any circumstances. "
-                "For Mermaid diagrams, use ONLY the default styling without colors, backgrounds, or custom styling attributes. "
-                "Keep Mermaid diagrams simple and minimal without any styling or color modifications. "
-                "Captions must appear immediately after the closing ``` on a new line starting with 'Caption:' - "
-                "no empty lines between the code block and the caption."
-            )
-            .build()
-        )
+        # Return default if not found
+        return CodeLanguage.PLAIN_TEXT
 
     @staticmethod
-    def extract_content(rich_text_list: list[dict[str, Any]]) -> str:
+    def extract_content(rich_text_list: list[RichTextObject]) -> str:
         """Extract code content from rich_text array."""
-        return "".join(
-            text.get("text", {}).get("content", "")
-            if text.get("type") == "text"
-            else text.get("plain_text", "")
-            for text in rich_text_list
-        )
+        return "".join(rt.plain_text for rt in rich_text_list if rt.plain_text)
 
     @staticmethod
-    def extract_caption(caption_list: list[dict[str, Any]]) -> str:
+    def extract_caption(caption_list: list[RichTextObject]) -> str:
         """Extract caption text from caption array."""
-        return "".join(
-            c.get("text", {}).get("content", "")
-            for c in caption_list
-            if c.get("type") == "text"
-        )
+        return "".join(rt.plain_text for rt in caption_list if rt.plain_text)
+
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for code blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Code blocks display syntax-highlighted code with optional language specification and captions",
+            syntax_examples=[
+                "```\nprint('Hello World')\n```",
+                "```python\nprint('Hello World')\n```",
+                "```python \"Example code\"\nprint('Hello World')\n```",
+                "```javascript\nconsole.log('Hello');\n```",
+            ],
+            usage_guidelines="Use for displaying code snippets. Language specification enables syntax highlighting. Caption in quotes on first line provides description. Supports many programming languages.",
+        )

notionary/blocks/code/code_markdown_node.py

@@ -1,24 +1,20 @@
 from __future__ import annotations
 
 from typing import Optional
-from pydantic import BaseModel
-from notionary.blocks.markdown_node import MarkdownNode
 
-
-class CodeMarkdownBlockParams(BaseModel):
-    code: str
-    language: Optional[str] = None
-    caption: Optional[str] = None
+from notionary.blocks.code.code_models import CodeBlock
+from notionary.markdown.markdown_node import MarkdownNode
 
 
 class CodeMarkdownNode(MarkdownNode):
     """
     Programmatic interface for creating Notion-style Markdown code blocks.
+    Automatically handles indentation normalization for multiline strings.
+
     Example:
-        ```python
+        ```python "Basic usage"
         print("Hello, world!")
         ```
-        Caption: Basic usage
     """
 
     def __init__(
@@ -32,12 +28,67 @@ class CodeMarkdownNode(MarkdownNode):
         self.caption = caption
 
     @classmethod
-    def from_params(cls, params: CodeMarkdownBlockParams) -> CodeMarkdownNode:
-        return cls(code=params.code, language=params.language, caption=params.caption)
+    def from_params(cls, params: CodeBlock) -> CodeMarkdownNode:
+        return cls(
+            code=params.rich_text, language=params.language, caption=params.caption
+        )
 
     def to_markdown(self) -> str:
         lang = self.language or ""
-        content = f"```{lang}\n{self.code}\n```"
+
+        # Build the opening fence with optional caption
+        opening_fence = f"```{lang}"
         if self.caption:
-            content += f"\nCaption: {self.caption}"
+            opening_fence += f' "{self.caption}"'
+
+        # Smart indentation normalization
+        normalized_code = self._normalize_indentation(self.code)
+
+        content = f"{opening_fence}\n{normalized_code}\n```"
         return content
+
+    def _normalize_indentation(self, code: str) -> str:
+        """Normalize indentation by removing common leading whitespace."""
+        lines = code.strip().split("\n")
+
+        if self._is_empty_or_single_line(lines):
+            return self._handle_simple_cases(lines)
+
+        min_indentation = self._find_minimum_indentation_excluding_first_line(lines)
+        return self._remove_common_indentation(lines, min_indentation)
+
+    def _is_empty_or_single_line(self, lines: list[str]) -> bool:
+        return not lines or len(lines) == 1
+
+    def _handle_simple_cases(self, lines: list[str]) -> str:
+        if not lines:
+            return ""
+        return lines[0].strip()
+
+    def _find_minimum_indentation_excluding_first_line(self, lines: list[str]) -> int:
+        non_empty_lines_after_first = [line for line in lines[1:] if line.strip()]
+
+        if not non_empty_lines_after_first:
+            return 0
+
+        return min(
+            len(line) - len(line.lstrip()) for line in non_empty_lines_after_first
+        )
+
+    def _remove_common_indentation(self, lines: list[str], min_indentation: int) -> str:
+        normalized_lines = [lines[0].strip()]
+
+        for line in lines[1:]:
+            normalized_line = self._normalize_single_line(line, min_indentation)
+            normalized_lines.append(normalized_line)
+
+        return "\n".join(normalized_lines)
+
+    def _normalize_single_line(self, line: str, min_indentation: int) -> str:
+        if not line.strip():
+            return ""
+
+        if len(line) > min_indentation:
+            return line[min_indentation:]
+
+        return line.strip()