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

notionary/page/page_content_deleting_service.py

@@ -1,117 +0,0 @@
-from typing import Optional
-
-from notionary.blocks.client import NotionBlockClient
-from notionary.blocks.models import Block
-from notionary.blocks.registry.block_registry import BlockRegistry
-from notionary.page.reader.page_content_retriever import PageContentRetriever
-from notionary.util import LoggingMixin
-
-
-class PageContentDeletingService(LoggingMixin):
-    """Service responsible for deleting page content and blocks."""
-
-    def __init__(self, page_id: str, block_registry: BlockRegistry):
-        self.page_id = page_id
-        self.block_registry = block_registry
-        self._block_client = NotionBlockClient()
-        self._content_retriever = PageContentRetriever(block_registry=block_registry)
-
-    async def clear_page_content(self) -> Optional[str]:
-        """Clear all content of the page and return deleted content as markdown."""
-        try:
-            children_response = await self._block_client.get_block_children(
-                block_id=self.page_id
-            )
-
-            if not children_response or not children_response.results:
-                return None
-
-            # Use PageContentRetriever for sophisticated markdown conversion
-            deleted_content = await self._content_retriever._convert_blocks_to_markdown(
-                children_response.results, indent_level=0
-            )
-
-            # Delete blocks
-            success = True
-            for block in children_response.results:
-                block_success = await self._delete_block_with_children(block)
-                if not block_success:
-                    success = False
-
-            if not success:
-                self.logger.warning("Some blocks could not be deleted")
-
-            return deleted_content if deleted_content else None
-
-        except Exception:
-            self.logger.error("Error clearing page content", exc_info=True)
-            return None
-
-    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.has_children and not await self._delete_block_children(block):
-                return False
-
-            return await self._delete_single_block(block)
-
-        except Exception as e:
-            self.logger.error("Failed to delete block %s: %s", block.id, str(e))
-            return False
-
-    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)
-
-        try:
-            children_blocks = await self._block_client.get_all_block_children(block.id)
-
-            if not children_blocks:
-                self.logger.debug("No children found for block: %s", block.id)
-                return True
-
-            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
-
-            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
-
-    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

notionary/page/page_content_writer.py

@@ -1,80 +0,0 @@
-from typing import Callable, Optional, Union
-
-from notionary.blocks.client import NotionBlockClient
-from notionary.blocks.registry.block_registry import BlockRegistry
-from notionary.blocks.markdown.markdown_builder import MarkdownBuilder
-from notionary.schemas.base import NotionContentSchema
-from notionary.page.markdown_whitespace_processor import MarkdownWhitespaceProcessor
-from notionary.page.writer.markdown_to_notion_converter import MarkdownToNotionConverter
-from notionary.util import LoggingMixin
-
-
-class PageContentWriter(LoggingMixin):
-    def __init__(self, page_id: str, block_registry: BlockRegistry):
-        self.page_id = page_id
-        self.block_registry = block_registry
-        self._block_client = NotionBlockClient()
-
-        self._markdown_to_notion_converter = MarkdownToNotionConverter(
-            block_registry=block_registry
-        )
-
-    async def append_markdown(
-        self,
-        content: Union[
-            str, Callable[[MarkdownBuilder], MarkdownBuilder], NotionContentSchema
-        ],
-    ) -> Optional[str]:
-        """
-        Append markdown content to a Notion page using text, builder callback, MarkdownDocumentModel, or NotionContentSchema.
-        """
-        markdown = self._extract_markdown_from_param(content)
-
-        processed_markdown = MarkdownWhitespaceProcessor.process_markdown_whitespace(
-            markdown
-        )
-
-        try:
-            blocks = await self._markdown_to_notion_converter.convert(
-                processed_markdown
-            )
-
-            result = await self._block_client.append_block_children(
-                block_id=self.page_id, children=blocks
-            )
-
-            if result:
-                self.logger.debug("Successfully appended %d blocks", len(blocks))
-                return processed_markdown
-            else:
-                self.logger.error("Failed to append blocks")
-                return None
-
-        except Exception as e:
-            self.logger.error("Error appending markdown: %s", str(e), exc_info=True)
-            return None
-
-    def _extract_markdown_from_param(
-        self,
-        content: Union[
-            str, Callable[[MarkdownBuilder], MarkdownBuilder], NotionContentSchema
-        ],
-    ) -> str:
-        """
-        Prepare markdown content from string, builder callback, MarkdownDocumentModel, or NotionContentSchema.
-        """
-        if isinstance(content, str):
-            return content
-        elif isinstance(content, NotionContentSchema):
-            # Use new injection-based API
-            builder = MarkdownBuilder()
-            return content.to_notion_content(builder)
-
-        elif callable(content):
-            builder = MarkdownBuilder()
-            content(builder)
-            return builder.build()
-        else:
-            raise ValueError(
-                "content must be either a string, a NotionContentSchema, a MarkdownDocumentModel, or a callable that takes a MarkdownBuilder"
-            )

notionary/page/property_formatter.py

@@ -1,99 +0,0 @@
-from typing import Any, Dict, Optional
-
-from notionary.util import LoggingMixin
-
-
-# TODO: mit dem Utils.py hier im order zusammenfassen
-class NotionPropertyFormatter(LoggingMixin):
-    """Class for formatting Notion properties based on their type."""
-
-    def __init__(self):
-        self._formatters = {
-            "title": self.format_title,
-            "rich_text": self.format_rich_text,
-            "url": self.format_url,
-            "email": self.format_email,
-            "phone_number": self.format_phone_number,
-            "number": self.format_number,
-            "checkbox": self.format_checkbox,
-            "select": self.format_select,
-            "multi_select": self.format_multi_select,
-            "date": self.format_date,
-            "status": self.format_status,
-            "relation": self.format_relation,
-        }
-
-    def format_title(self, value: Any) -> Dict[str, Any]:
-        """Formats a title value."""
-        return {"title": [{"type": "text", "text": {"content": str(value)}}]}
-
-    def format_rich_text(self, value: Any) -> Dict[str, Any]:
-        """Formats a rich text value."""
-        return {"rich_text": [{"type": "text", "text": {"content": str(value)}}]}
-
-    def format_url(self, value: str) -> Dict[str, Any]:
-        """Formats a URL value."""
-        return {"url": value}
-
-    def format_email(self, value: str) -> Dict[str, Any]:
-        """Formats an email address."""
-        return {"email": value}
-
-    def format_phone_number(self, value: str) -> Dict[str, Any]:
-        """Formats a phone number."""
-        return {"phone_number": value}
-
-    def format_number(self, value: Any) -> Dict[str, Any]:
-        """Formats a numeric value."""
-        return {"number": float(value)}
-
-    def format_checkbox(self, value: Any) -> Dict[str, Any]:
-        """Formats a checkbox value."""
-        return {"checkbox": bool(value)}
-
-    def format_select(self, value: str) -> Dict[str, Any]:
-        """Formats a select value."""
-        return {"select": {"name": str(value)}}
-
-    def format_multi_select(self, value: Any) -> Dict[str, Any]:
-        """Formats a multi-select value."""
-        if isinstance(value, list):
-            return {"multi_select": [{"name": item} for item in value]}
-        return {"multi_select": [{"name": str(value)}]}
-
-    def format_date(self, value: Any) -> Dict[str, Any]:
-        """Formats a date value."""
-        if isinstance(value, dict) and "start" in value:
-            return {"date": value}
-        return {"date": {"start": str(value)}}
-
-    def format_status(self, value: str) -> Dict[str, Any]:
-        """Formats a status value."""
-        return {"status": {"name": str(value)}}
-
-    def format_relation(self, value: Any) -> Dict[str, Any]:
-        """Formats a relation value."""
-        if isinstance(value, list):
-            return {"relation": [{"id": item} for item in value]}
-        return {"relation": [{"id": str(value)}]}
-
-    def format_value(
-        self, property_name, property_type: str, value: Any
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Formats a value according to the given Notion property type.
-
-        Args:
-            property_type: Notion property type (e.g., "title", "rich_text", "status")
-            value: The value to be formatted
-
-        Returns:
-            A dictionary with the formatted value, or None if the type is unknown.
-        """
-        formatter = self._formatters.get(property_type)
-        if not formatter:
-            self.logger.warning("Unknown property type: %s", property_type)
-            return None
-
-        formatted_property = formatter(value)
-        return {"properties": {property_name: formatted_property}}

notionary/page/reader/handler/__init__.py

@@ -1,19 +0,0 @@
-from .base_block_renderer import BlockHandler
-from .block_rendering_context import BlockRenderingContext
-from .column_list_renderer import ColumnListRenderer
-from .column_renderer import ColumnRenderer
-from .line_renderer import LineRenderer
-from .numbered_list_renderer import NumberedListRenderer
-from .toggle_renderer import ToggleRenderer
-from .toggleable_heading_renderer import ToggleableHeadingRenderer
-
-__all__ = [
-    "BlockHandler",
-    "BlockRenderingContext",
-    "ColumnListRenderer",
-    "ColumnRenderer",
-    "LineRenderer",
-    "NumberedListRenderer",
-    "ToggleRenderer",
-    "ToggleableHeadingRenderer",
-]

notionary/page/reader/handler/base_block_renderer.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Optional
-
-from notionary.page.reader.handler.block_rendering_context import BlockRenderingContext
-
-
-class BlockHandler(ABC):
-    """Abstract base class for block handlers."""
-
-    def __init__(self):
-        self._next_handler: Optional[BlockHandler] = None
-
-    def set_next(self, handler: BlockHandler) -> BlockHandler:
-        """Set the next handler in the chain."""
-        self._next_handler = handler
-        return handler
-
-    async def handle(self, context: BlockRenderingContext) -> None:
-        """Handle the block or pass to next handler."""
-        if self._can_handle(context):
-            await self._process(context)
-        elif self._next_handler:
-            await self._next_handler.handle(context)
-
-    @abstractmethod
-    def _can_handle(self, context: BlockRenderingContext) -> bool:
-        """Check if this handler can process the current block."""
-        pass
-
-    @abstractmethod
-    async def _process(self, context: BlockRenderingContext) -> None:
-        """Process the block and update context."""
-        pass
-
-    def _indent_text(self, text: str, spaces: int = 4) -> str:
-        """Indent each line of text with specified number of spaces."""
-        if not text:
-            return text
-
-        indent = " " * spaces
-        lines = text.split("\n")
-        return "\n".join(f"{indent}{line}" if line.strip() else line for line in lines)

notionary/page/reader/handler/block_processing_context.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Optional
-
-from notionary.blocks.models import Block
-from notionary.blocks.registry.block_registry import BlockRegistry
-
-
-@dataclass
-class BlockProcessingContext:
-    """Context for processing blocks during markdown conversion."""
-
-    block: Block
-    indent_level: int
-    block_registry: BlockRegistry
-
-    # Result
-    markdown_result: Optional[str] = None
-    children_result: Optional[str] = None
-    was_processed: bool = False
-
-    def has_children(self) -> bool:
-        """Check if block has children that need processing."""
-        return (
-            self.block.has_children
-            and self.block.children is not None
-            and len(self.block.children) > 0
-        )
-
-    def get_children_blocks(self) -> list[Block]:
-        """Get the children blocks safely."""
-        if self.has_children():
-            return self.block.children
-        return []

notionary/page/reader/handler/block_rendering_context.py

@@ -1,48 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Callable, Optional
-
-from notionary.blocks.models import Block
-from notionary.blocks.registry.block_registry import BlockRegistry
-
-
-@dataclass
-class BlockRenderingContext:
-    """Context for processing blocks during markdown conversion."""
-
-    block: Block
-    indent_level: int
-    block_registry: BlockRegistry
-    convert_children_callback: Optional[Callable[[list[Block], int], str]] = None
-
-    # For batch processing
-    all_blocks: Optional[list[Block]] = None
-    current_block_index: Optional[int] = None
-    blocks_consumed: int = 0
-
-    # Result
-    markdown_result: Optional[str] = None
-    children_result: Optional[str] = None
-    was_processed: bool = False
-
-    def has_children(self) -> bool:
-        """Check if block has children that need processing."""
-        return (
-            self.block.has_children
-            and self.block.children is not None
-            and len(self.block.children) > 0
-        )
-
-    def get_children_blocks(self) -> list[Block]:
-        """Get the children blocks safely."""
-        if self.has_children():
-            return self.block.children
-        return []
-
-    def convert_children_to_markdown(self, indent_level: int = 0) -> str:
-        """Convert children blocks to markdown using the callback."""
-        if not self.has_children() or not self.convert_children_callback:
-            return ""
-
-        return self.convert_children_callback(self.get_children_blocks(), indent_level)

notionary/page/reader/handler/column_list_renderer.py

@@ -1,51 +0,0 @@
-from notionary.blocks.column.column_list_element import ColumnListElement
-from notionary.page.reader.handler import BlockHandler, BlockRenderingContext
-
-
-class ColumnListRenderer(BlockHandler):
-    """Handles column list blocks with their column children."""
-
-    def _can_handle(self, context: BlockRenderingContext) -> bool:
-        return ColumnListElement.match_notion(context.block)
-
-    async def _process(self, context: BlockRenderingContext) -> None:
-        # Create column list start line
-        column_list_start = "::: columns"
-
-        # Apply indentation if needed
-        if context.indent_level > 0:
-            column_list_start = self._indent_text(
-                column_list_start, spaces=context.indent_level * 4
-            )
-
-        # Process children if they exist
-        children_markdown = ""
-        if context.has_children():
-            # Import here to avoid circular dependency
-            from notionary.page.reader.page_content_retriever import (
-                PageContentRetriever,
-            )
-
-            # Create a temporary retriever to process children
-            retriever = PageContentRetriever(context.block_registry)
-            children_markdown = await retriever._convert_blocks_to_markdown(
-                context.get_children_blocks(),
-                indent_level=0,  # No indentation for content inside column lists
-            )
-
-        # Create column list end line
-        column_list_end = ":::"
-        if context.indent_level > 0:
-            column_list_end = self._indent_text(
-                column_list_end, spaces=context.indent_level * 4
-            )
-
-        # Combine column list with children content
-        if children_markdown:
-            context.markdown_result = (
-                f"{column_list_start}\n{children_markdown}\n{column_list_end}"
-            )
-        else:
-            context.markdown_result = f"{column_list_start}\n{column_list_end}"
-
-        context.was_processed = True

notionary/page/reader/handler/column_renderer.py

@@ -1,60 +0,0 @@
-from notionary.blocks.column.column_element import ColumnElement
-from notionary.page.reader.handler import BlockHandler, BlockRenderingContext
-
-
-class ColumnRenderer(BlockHandler):
-    """Handles individual column blocks with their children content."""
-
-    def _can_handle(self, context: BlockRenderingContext) -> bool:
-        return ColumnElement.match_notion(context.block)
-
-    async def _process(self, context: BlockRenderingContext) -> None:
-        # Get the column start line with potential width ratio
-        column_start = self._extract_column_start(context.block)
-
-        # Apply indentation if needed
-        if context.indent_level > 0:
-            column_start = self._indent_text(
-                column_start, spaces=context.indent_level * 4
-            )
-
-        # Process children if they exist
-        children_markdown = ""
-        if context.has_children():
-            # Import here to avoid circular dependency
-            from notionary.page.reader.page_content_retriever import (
-                PageContentRetriever,
-            )
-
-            # Create a temporary retriever to process children
-            retriever = PageContentRetriever(context.block_registry)
-            children_markdown = await retriever._convert_blocks_to_markdown(
-                context.get_children_blocks(),
-                indent_level=0,  # No indentation for content inside columns
-            )
-
-        # Create column end line
-        column_end = ":::"
-        if context.indent_level > 0:
-            column_end = self._indent_text(column_end, spaces=context.indent_level * 4)
-
-        # Combine column with children content
-        if children_markdown:
-            context.markdown_result = (
-                f"{column_start}\n{children_markdown}\n{column_end}"
-            )
-        else:
-            context.markdown_result = f"{column_start}\n{column_end}"
-
-        context.was_processed = True
-
-    def _extract_column_start(self, block) -> str:
-        """Extract column start line with potential width ratio."""
-        if not block.column:
-            return "::: column"
-
-        width_ratio = block.column.width_ratio
-        if width_ratio:
-            return f"::: column {width_ratio}"
-        else:
-            return "::: column"

notionary/page/reader/handler/line_renderer.py

@@ -1,73 +0,0 @@
-from __future__ import annotations
-
-from typing import Optional
-
-from notionary.page.reader.handler import BlockHandler, BlockRenderingContext
-
-
-class LineRenderer(BlockHandler):
-    """Handles all regular blocks that don't need special parent/children processing."""
-
-    def _can_handle(self, context: BlockRenderingContext) -> bool:
-        # Always can handle - this is the fallback handler
-        return True
-
-    async def _process(self, context: BlockRenderingContext) -> None:
-        # Convert the block itself using direct element iteration
-        block_markdown = await self._convert_block_to_markdown(context)
-
-        # If block has no direct markdown, either return empty or process children
-        if not block_markdown:
-            if not context.has_children():
-                context.markdown_result = ""
-                context.was_processed = True
-                return
-
-            # Import here to avoid circular dependency and process children
-            from notionary.page.reader.page_content_retriever import (
-                PageContentRetriever,
-            )
-
-            retriever = PageContentRetriever(context.block_registry)
-            children_markdown = await retriever._convert_blocks_to_markdown(
-                context.get_children_blocks(), indent_level=context.indent_level + 1
-            )
-            context.markdown_result = children_markdown
-            context.was_processed = True
-            return
-
-        # Apply indentation if needed
-        if context.indent_level > 0:
-            block_markdown = self._indent_text(
-                block_markdown, spaces=context.indent_level * 4
-            )
-
-        # If there are no children, return the block markdown directly
-        if not context.has_children():
-            context.markdown_result = block_markdown
-            context.was_processed = True
-            return
-
-        # Otherwise process children and combine
-        from notionary.page.reader.page_content_retriever import PageContentRetriever
-
-        retriever = PageContentRetriever(context.block_registry)
-        children_markdown = await retriever._convert_blocks_to_markdown(
-            context.get_children_blocks(), indent_level=context.indent_level + 1
-        )
-
-        context.markdown_result = (
-            f"{block_markdown}\n{children_markdown}"
-            if children_markdown
-            else block_markdown
-        )
-        context.was_processed = True
-
-    async def _convert_block_to_markdown(
-        self, context: BlockRenderingContext
-    ) -> Optional[str]:
-        """Convert a Notion block to markdown using registered elements."""
-        for element in context.block_registry.get_elements():
-            if element.match_notion(context.block):
-                return await element.notion_to_markdown(context.block)
-        return None