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

notionary/page/content/page_content_writer.py

@@ -1,49 +1,31 @@
-from typing import Any, Dict
+from typing import Optional
 
-from notionary.blocks import DividerElement, BlockRegistry
-
-from notionary.page.client import NotionPageClient
+from notionary.blocks import BlockRegistry
+from notionary.blocks.shared.block_client import NotionBlockClient
+from notionary.models.notion_block_response import Block
+from notionary.page.content.markdown_whitespace_processor import (
+    MarkdownWhitespaceProcessor,
+)
+from notionary.page.content.notion_text_length_utils import fix_blocks_content_length
 from notionary.page.formatting.markdown_to_notion_converter import (
     MarkdownToNotionConverter,
 )
-from notionary.page.notion_to_markdown_converter import (
-    NotionToMarkdownConverter,
-)
-from notionary.page.content.notion_page_content_chunker import (
-    NotionPageContentChunker,
-)
+
 from notionary.util import LoggingMixin
 
 
 class PageContentWriter(LoggingMixin):
-    def __init__(
-        self,
-        page_id: str,
-        client: NotionPageClient,
-        block_registry: BlockRegistry,
-    ):
+    def __init__(self, page_id: str, block_registry: BlockRegistry):
         self.page_id = page_id
-        self._client = client
         self.block_registry = block_registry
+        self._block_client = NotionBlockClient()
+
         self._markdown_to_notion_converter = MarkdownToNotionConverter(
             block_registry=block_registry
         )
-        self._notion_to_markdown_converter = NotionToMarkdownConverter(
-            block_registry=block_registry
-        )
-        self._chunker = NotionPageContentChunker()
-
-    async def append_markdown(self, markdown_text: str, append_divider=False) -> bool:
-        """
-        Append markdown text to a Notion page, automatically handling content length limits.
-        """
-        if append_divider and not self.block_registry.contains(DividerElement):
-            self.logger.warning(
-                "DividerElement not registered. Appending divider skipped."
-            )
-            append_divider = False
 
-        # Append divider in markdown format as it will be converted to a Notion divider block
+    async def append_markdown(self, markdown_text: str, append_divider=True) -> bool:
+        """Append markdown text to a Notion page, automatically handling content length limits."""
         if append_divider:
             markdown_text = markdown_text + "---\n"
 
@@ -51,29 +33,36 @@ class PageContentWriter(LoggingMixin):
 
         try:
             blocks = self._markdown_to_notion_converter.convert(markdown_text)
-            fixed_blocks = self._chunker.fix_blocks_content_length(blocks)
 
-            result = await self._client.patch(
-                f"blocks/{self.page_id}/children", {"children": fixed_blocks}
+            fixed_blocks = fix_blocks_content_length(blocks)
+
+            result = await self._block_client.append_block_children(
+                block_id=self.page_id, children=fixed_blocks
             )
+            self.logger.debug("Append block children result: %r", result)
             return bool(result)
         except Exception as e:
-            self.logger.error("Error appending markdown: %s", str(e))
+            import traceback
+
+            self.logger.error(
+                "Error appending markdown: %s\nTraceback:\n%s",
+                str(e),
+                traceback.format_exc(),
+            )
             return False
 
     async def clear_page_content(self) -> bool:
-        """
-        Clear all content of the page.
-        """
+        """Clear all content of the page."""
         try:
-            blocks_resp = await self._client.get(f"blocks/{self.page_id}/children")
-            results = blocks_resp.get("results", []) if blocks_resp else []
+            children_response = await self._block_client.get_block_children(
+                block_id=self.page_id
+            )
 
-            if not results:
+            if not children_response or not children_response.results:
                 return True
 
             success = True
-            for block in results:
+            for block in children_response.results:
                 block_success = await self._delete_block_with_children(block)
                 if not block_success:
                     success = False
@@ -83,120 +72,80 @@ class PageContentWriter(LoggingMixin):
             self.logger.error("Error clearing page content: %s", str(e))
             return False
 
-    async def _delete_block_with_children(self, block: Dict[str, Any]) -> bool:
-        """
-        Delete a block and all its children.
-        """
+    async def _delete_block_with_children(self, block: Block) -> bool:
+        """Delete a block and all its children recursively."""
+        if not block.id:
+            self.logger.error("Block has no valid ID")
+            return False
+
+        self.logger.debug("Deleting block: %s (type: %s)", block.id, block.type)
+
         try:
-            if block.get("has_children", False):
-                children_resp = await self._client.get(f"blocks/{block['id']}/children")
-                child_results = children_resp.get("results", [])
+            if block.has_children and not await self._delete_block_children(block):
+                return False
 
-                for child in child_results:
-                    child_success = await self._delete_block_with_children(child)
-                    if not child_success:
-                        return False
+            return await self._delete_single_block(block)
 
-            return await self._client.delete(f"blocks/{block['id']}")
         except Exception as e:
-            self.logger.error("Failed to delete block: %s", str(e))
+            self.logger.error("Failed to delete block %s: %s", block.id, str(e))
             return False
 
-    def _process_markdown_whitespace(self, markdown_text: str) -> str:
-        """
-        Process markdown text to preserve code structure while removing unnecessary indentation.
-        Strips all leading whitespace from regular lines, but preserves relative indentation
-        within code blocks.
+    async def _delete_block_children(self, block: Block) -> bool:
+        """Delete all children of a block."""
+        self.logger.debug("Block %s has children, deleting children first", block.id)
 
-        Args:
-            markdown_text: Original markdown text with potential leading whitespace
+        try:
+            children_blocks = await self._block_client.get_all_block_children(block.id)
 
-        Returns:
-            Processed markdown text with corrected whitespace
-        """
-        lines = markdown_text.split("\n")
-        if not lines:
-            return ""
+            if not children_blocks:
+                self.logger.debug("No children found for block: %s", block.id)
+                return True
 
-        processed_lines = []
-        in_code_block = False
-        current_code_block = []
-
-        for line in lines:
-            # Handle code block markers
-            if self._is_code_block_marker(line):
-                if not in_code_block:
-                    # Starting a new code block
-                    in_code_block = True
-                    processed_lines.append(self._process_code_block_start(line))
-                    current_code_block = []
-                    continue
-
-                # Ending a code block
-                processed_lines.extend(
-                    self._process_code_block_content(current_code_block)
-                )
-                processed_lines.append("```")
-                in_code_block = False
-                continue
-
-            # Handle code block content
-            if in_code_block:
-                current_code_block.append(line)
-                continue
-
-            # Handle regular text
-            processed_lines.append(line.lstrip())
-
-        # Handle unclosed code block
-        if in_code_block and current_code_block:
-            processed_lines.extend(self._process_code_block_content(current_code_block))
-            processed_lines.append("```")
-
-        return "\n".join(processed_lines)
-
-    def _is_code_block_marker(self, line: str) -> bool:
-        """Check if a line is a code block marker."""
-        return line.lstrip().startswith("```")
-
-    def _process_code_block_start(self, line: str) -> str:
-        """Extract and normalize the code block opening marker."""
-        language = line.lstrip().replace("```", "", 1).strip()
-        return "```" + language
-
-    def _process_code_block_content(self, code_lines: list) -> list:
-        """
-        Normalize code block indentation by removing the minimum common indentation.
-
-        Args:
-            code_lines: List of code block content lines
-
-        Returns:
-            List of processed code lines with normalized indentation
-        """
-        if not code_lines:
-            return []
-
-        # Find non-empty lines to determine minimum indentation
-        non_empty_code_lines = [line for line in code_lines if line.strip()]
-        if not non_empty_code_lines:
-            return [""] * len(code_lines)  # All empty lines stay empty
-
-        # Calculate minimum indentation
-        min_indent = min(
-            len(line) - len(line.lstrip()) for line in non_empty_code_lines
-        )
-        if min_indent == 0:
-            return code_lines  # No common indentation to remove
+            self.logger.debug(
+                "Found %d children to delete for block: %s",
+                len(children_blocks),
+                block.id,
+            )
+
+            # Delete all children recursively
+            for child_block in children_blocks:
+                if not await self._delete_block_with_children(child_block):
+                    self.logger.error(
+                        "Failed to delete child block: %s", child_block.id
+                    )
+                    return False
 
-        # Process each line
-        processed_code_lines = []
-        for line in code_lines:
-            if not line.strip():
-                processed_code_lines.append("")  # Keep empty lines empty
-                continue
+            self.logger.debug(
+                "Successfully deleted all children of block: %s", block.id
+            )
+            return True
+
+        except Exception as e:
+            self.logger.error(
+                "Failed to delete children of block %s: %s", block.id, str(e)
+            )
+            return False
 
-            # Remove exactly the minimum indentation
-            processed_code_lines.append(line[min_indent:])
+    async def _delete_single_block(self, block: Block) -> bool:
+        """Delete a single block."""
+        deleted_block: Optional[Block] = await self._block_client.delete_block(block.id)
+
+        if deleted_block is None:
+            self.logger.error("Failed to delete block: %s", block.id)
+            return False
+
+        if deleted_block.archived or deleted_block.in_trash:
+            self.logger.debug("Successfully deleted/archived block: %s", block.id)
+            return True
+        else:
+            self.logger.warning("Block %s was not properly archived/deleted", block.id)
+            return False
+
+    def _process_markdown_whitespace(self, markdown_text: str) -> str:
+        """Process markdown text to normalize whitespace while preserving code blocks."""
+        lines = markdown_text.split("\n")
+        if not lines:
+            return ""
 
-        return processed_code_lines
+        processor = MarkdownWhitespaceProcessor()
+        return processor.process_lines(lines)

notionary/page/formatting/line_processor.py

@@ -0,0 +1,153 @@
+import re
+from notionary.blocks.shared.notion_block_element import NotionBlock
+from notionary.blocks.registry.block_registry import BlockRegistry
+
+
+class LineProcessingState:
+    """Tracks state during line-by-line processing"""
+
+    def __init__(self):
+        self.paragraph_lines: list[str] = []
+        self.paragraph_start: int = 0
+
+    def add_to_paragraph(self, line: str, current_pos: int):
+        """Add line to current paragraph"""
+        if not self.paragraph_lines:
+            self.paragraph_start = current_pos
+        self.paragraph_lines.append(line)
+
+    def reset_paragraph(self):
+        """Reset paragraph state"""
+        self.paragraph_lines = []
+        self.paragraph_start = 0
+
+    def has_paragraph(self) -> bool:
+        """Check if there are paragraph lines to process"""
+        return len(self.paragraph_lines) > 0
+
+
+class LineProcessor:
+    """Handles line-by-line processing of markdown text"""
+
+    def __init__(
+        self,
+        block_registry: BlockRegistry,
+        excluded_ranges: set[int],
+        pipe_pattern: str,
+    ):
+        self._block_registry = block_registry
+        self._excluded_ranges = excluded_ranges
+        self._pipe_pattern = pipe_pattern
+
+    @staticmethod
+    def _normalize_to_list(result) -> list[dict[str, any]]:
+        """Normalize Union[list[dict], dict] to list[dict]"""
+        if result is None:
+            return []
+        return result if isinstance(result, list) else [result]
+
+    def process_lines(self, text: str) -> list[tuple[int, int, dict[str, any]]]:
+        """Process all lines and return blocks with positions"""
+        lines = text.split("\n")
+        line_blocks = []
+
+        state = LineProcessingState()
+        current_pos = 0
+
+        for line in lines:
+            line_length = len(line) + 1  # +1 for newline
+            line_end = current_pos + line_length - 1
+
+            if self._should_skip_line(line, current_pos, line_end):
+                current_pos += line_length
+                continue
+
+            self._process_single_line(line, current_pos, line_end, line_blocks, state)
+            current_pos += line_length
+
+        # Process any remaining paragraph
+        self._finalize_paragraph(state, current_pos, line_blocks)
+
+        return line_blocks
+
+    def _should_skip_line(self, line: str, current_pos: int, line_end: int) -> bool:
+        """Check if line should be skipped (excluded or pipe syntax)"""
+        return self._overlaps_with_excluded(
+            current_pos, line_end
+        ) or self._is_pipe_syntax_line(line)
+
+    def _overlaps_with_excluded(self, start_pos: int, end_pos: int) -> bool:
+        """Check if position range overlaps with excluded ranges"""
+        return any(
+            pos in self._excluded_ranges for pos in range(start_pos, end_pos + 1)
+        )
+
+    def _is_pipe_syntax_line(self, line: str) -> bool:
+        """Check if line uses pipe syntax for nested content"""
+        return bool(re.match(self._pipe_pattern, line))
+
+    def _process_single_line(
+        self,
+        line: str,
+        current_pos: int,
+        line_end: int,
+        line_blocks: list[tuple[int, int, dict[str, any]]],
+        state: LineProcessingState,
+    ):
+        """Process a single line of text"""
+        # Handle empty lines
+        if not line.strip():
+            self._finalize_paragraph(state, current_pos, line_blocks)
+            state.reset_paragraph()
+            return
+
+        # Handle special blocks (headings, todos, dividers, etc.)
+        special_blocks = self._extract_special_block(line)
+        if special_blocks:
+            self._finalize_paragraph(state, current_pos, line_blocks)
+            # Mehrere Blöcke hinzufügen
+            for block in special_blocks:
+                line_blocks.append((current_pos, line_end, block))
+            state.reset_paragraph()
+            return
+
+        # Add to current paragraph
+        state.add_to_paragraph(line, current_pos)
+
+    def _extract_special_block(self, line: str) -> list[NotionBlock]:
+        """Extract special block (non-paragraph) from line"""
+        for element in (
+            element
+            for element in self._block_registry.get_elements()
+            if not element.is_multiline()
+        ):
+            if not element.match_markdown(line):
+                continue
+
+            result = element.markdown_to_notion(line)
+            blocks = self._normalize_to_list(result)
+            if not blocks:
+                continue
+
+            # Gibt nur zurück, wenn mindestens ein Nicht-Paragraph-Block dabei ist
+            if any(block.get("type") != "paragraph" for block in blocks):
+                return blocks
+
+        return []
+
+    def _finalize_paragraph(
+        self,
+        state: LineProcessingState,
+        end_pos: int,
+        line_blocks: list[tuple[int, int, dict[str, any]]],
+    ):
+        """Convert current paragraph lines to paragraph block"""
+        if not state.has_paragraph():
+            return
+
+        paragraph_text = "\n".join(state.paragraph_lines)
+        result = self._block_registry.markdown_to_notion(paragraph_text)
+        blocks = self._normalize_to_list(result)
+
+        for block in blocks:
+            line_blocks.append((state.paragraph_start, end_pos, block))