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

notionary/page/reader/handler/numbered_list_renderer.py

@@ -1,85 +0,0 @@
-from notionary.blocks.models import Block, BlockType
-from notionary.blocks.registry.block_registry import BlockRegistry
-from notionary.page.reader.handler.base_block_renderer import BlockHandler
-from notionary.page.reader.handler.block_rendering_context import BlockRenderingContext
-
-
-class NumberedListRenderer(BlockHandler):
-    """Handles numbered list items with sequential numbering."""
-
-    def _can_handle(self, context: BlockRenderingContext) -> bool:
-        """Check if this is a numbered list item."""
-        return (
-            context.block.type == BlockType.NUMBERED_LIST_ITEM
-            and context.block.numbered_list_item is not None
-        )
-
-    async def _process(self, context: BlockRenderingContext) -> None:
-        """Process numbered list item with sequential numbering."""
-        if context.all_blocks is None or context.current_block_index is None:
-            await self._process_single_item(context, 1)
-            return
-
-        items, blocks_to_skip = self._collect_numbered_list_items(context)
-
-        markdown_parts = []
-        for i, item_context in enumerate(items, 1):
-            item_markdown = await self._process_single_item(item_context, i)
-            if item_markdown:
-                markdown_parts.append(item_markdown)
-
-        # Set result and mark how many blocks to skip
-        if markdown_parts:
-            context.markdown_result = "\n".join(markdown_parts)
-            context.was_processed = True
-            context.blocks_consumed = blocks_to_skip
-
-    def _collect_numbered_list_items(
-        self, context: BlockRenderingContext
-    ) -> tuple[list[BlockRenderingContext], int]:
-        """Collect all consecutive numbered list items starting from current position."""
-        items = []
-        current_index = context.current_block_index
-        all_blocks = context.all_blocks
-
-        # Start with current block
-        items.append(context)
-        blocks_processed = 1
-
-        # Look ahead for more numbered list items
-        for i in range(current_index + 1, len(all_blocks)):
-            block = all_blocks[i]
-
-            # Check if it's a numbered list item
-            if (
-                block.type == BlockType.NUMBERED_LIST_ITEM
-                and block.numbered_list_item is not None
-            ):
-
-                # Create context for this item
-                item_context = BlockRenderingContext(
-                    block=block,
-                    indent_level=context.indent_level,
-                    block_registry=context.block_registry,
-                    convert_children_callback=context.convert_children_callback,
-                )
-                items.append(item_context)
-                blocks_processed += 1
-            else:
-                # Not a numbered list item - stop collecting
-                break
-
-        return items, blocks_processed
-
-    async def _process_single_item(
-        self, context: BlockRenderingContext, number: int
-    ) -> str:
-        """Process a single numbered list item with the given number."""
-        from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
-
-        rich_text = context.block.numbered_list_item.rich_text
-        content = await TextInlineFormatter.extract_text_with_formatting(rich_text)
-
-        # Apply indentation
-        indent = "  " * context.indent_level
-        return f"{indent}{number}. {content}"

notionary/page/reader/handler/toggle_renderer.py

@@ -1,69 +0,0 @@
-from notionary.blocks.toggle.toggle_element import ToggleElement
-from notionary.page.reader.handler import BlockHandler, BlockRenderingContext
-
-
-class ToggleRenderer(BlockHandler):
-    """Handles toggle blocks with their children content."""
-
-    def _can_handle(self, context: BlockRenderingContext) -> bool:
-        return ToggleElement.match_notion(context.block)
-
-    async def _process(self, context: BlockRenderingContext) -> None:
-        # Get the toggle title from the block
-        toggle_title = self._extract_toggle_title(context.block)
-
-        if not toggle_title:
-            return
-
-        # Create toggle start line
-        toggle_start = f"+++ {toggle_title}"
-
-        # Apply indentation if needed
-        if context.indent_level > 0:
-            toggle_start = self._indent_text(
-                toggle_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 toggles
-            )
-
-        # Create toggle end line
-        toggle_end = "+++"
-        if context.indent_level > 0:
-            toggle_end = self._indent_text(toggle_end, spaces=context.indent_level * 4)
-
-        # Combine toggle with children content
-        if children_markdown:
-            context.markdown_result = (
-                f"{toggle_start}\n{children_markdown}\n{toggle_end}"
-            )
-        else:
-            context.markdown_result = f"{toggle_start}\n{toggle_end}"
-
-        context.was_processed = True
-
-    def _extract_toggle_title(self, block) -> str:
-        """Extract toggle title from the block."""
-        if not block.toggle or not block.toggle.rich_text:
-            return ""
-
-        title = ""
-        for text_obj in block.toggle.rich_text:
-            if hasattr(text_obj, "plain_text"):
-                title += text_obj.plain_text or ""
-            elif hasattr(text_obj, "text") and hasattr(text_obj.text, "content"):
-                title += text_obj.text.content or ""
-
-        return title.strip()

notionary/page/reader/handler/toggleable_heading_renderer.py

@@ -1,89 +0,0 @@
-from notionary.blocks.toggleable_heading.toggleable_heading_element import (
-    ToggleableHeadingElement,
-)
-from notionary.blocks.types import BlockType
-from notionary.page.reader.handler import BlockHandler, BlockRenderingContext
-
-
-class ToggleableHeadingRenderer(BlockHandler):
-    """Handles toggleable heading blocks with their children content."""
-
-    def _can_handle(self, context: BlockRenderingContext) -> bool:
-        return ToggleableHeadingElement.match_notion(context.block)
-
-    async def _process(self, context: BlockRenderingContext) -> None:
-        # Get the heading level and title
-        level, title = self._extract_heading_info(context.block)
-
-        if not title or level == 0:
-            return
-
-        # Create toggleable heading start line
-        prefix = "+++" + ("#" * level)
-        heading_start = f"{prefix} {title}"
-
-        # Apply indentation if needed
-        if context.indent_level > 0:
-            heading_start = self._indent_text(
-                heading_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 toggleable headings
-            )
-
-        # Create toggleable heading end line
-        heading_end = "+++"
-        if context.indent_level > 0:
-            heading_end = self._indent_text(
-                heading_end, spaces=context.indent_level * 4
-            )
-
-        # Combine heading with children content
-        if children_markdown:
-            context.markdown_result = (
-                f"{heading_start}\n{children_markdown}\n{heading_end}"
-            )
-        else:
-            context.markdown_result = f"{heading_start}\n{heading_end}"
-
-        context.was_processed = True
-
-    def _extract_heading_info(self, block) -> tuple[int, str]:
-        """Extract heading level and title from the block."""
-        # Determine heading level from block type
-        if block.type == BlockType.HEADING_1:
-            level = 1
-            heading_content = block.heading_1
-        elif block.type == BlockType.HEADING_2:
-            level = 2
-            heading_content = block.heading_2
-        elif block.type == BlockType.HEADING_3:
-            level = 3
-            heading_content = block.heading_3
-        else:
-            return 0, ""
-
-        if not heading_content or not heading_content.rich_text:
-            return level, ""
-
-        # Extract title from rich_text
-        title = ""
-        for text_obj in heading_content.rich_text:
-            if hasattr(text_obj, "plain_text"):
-                title += text_obj.plain_text or ""
-            elif hasattr(text_obj, "text") and hasattr(text_obj.text, "content"):
-                title += text_obj.text.content or ""
-
-        return level, title.strip()

notionary/page/reader/page_content_retriever.py

@@ -1,81 +0,0 @@
-from notionary.blocks.models import Block
-from notionary.blocks.registry.block_registry import BlockRegistry
-from notionary.page.reader.handler import (
-    BlockRenderingContext,
-    ColumnListRenderer,
-    ColumnRenderer,
-    LineRenderer,
-    NumberedListRenderer,
-    ToggleableHeadingRenderer,
-    ToggleRenderer,
-)
-from notionary.util import LoggingMixin
-
-
-class PageContentRetriever(LoggingMixin):
-    """Retrieves Notion page content and converts it to Markdown using chain of responsibility."""
-
-    def __init__(
-        self,
-        block_registry: BlockRegistry,
-    ):
-        self._block_registry = block_registry
-
-        self._setup_handler_chain()
-
-    async def convert_to_markdown(self, blocks: list[Block]) -> str:
-        """
-        Retrieve page content and convert it to Markdown.
-        Uses the chain of responsibility pattern for scalable block processing.
-        """
-        return await self._convert_blocks_to_markdown(blocks, indent_level=0)
-
-    def _setup_handler_chain(self) -> None:
-        """Setup the chain of handlers in priority order."""
-        toggle_handler = ToggleRenderer()
-        toggleable_heading_handler = ToggleableHeadingRenderer()
-        column_list_handler = ColumnListRenderer()
-        column_handler = ColumnRenderer()
-        numbered_list_handler = NumberedListRenderer()
-        regular_handler = LineRenderer()
-
-        # Chain handlers - most specific first
-        toggle_handler.set_next(toggleable_heading_handler).set_next(
-            column_list_handler
-        ).set_next(column_handler).set_next(numbered_list_handler).set_next(
-            regular_handler
-        )
-
-        self._handler_chain = toggle_handler
-
-    async def _convert_blocks_to_markdown(
-        self, blocks: list[Block], indent_level: int = 0
-    ) -> str:
-        """Convert blocks to Markdown using the handler chain."""
-        if not blocks:
-            return ""
-
-        markdown_parts = []
-        i = 0
-
-        while i < len(blocks):
-            block = blocks[i]
-            context = BlockRenderingContext(
-                block=block,
-                indent_level=indent_level,
-                block_registry=self._block_registry,
-                all_blocks=blocks,
-                current_block_index=i,
-                convert_children_callback=self._convert_blocks_to_markdown,
-            )
-
-            await self._handler_chain.handle(context)
-
-            if context.was_processed and context.markdown_result:
-                markdown_parts.append(context.markdown_result)
-
-            # Skip additional blocks if they were consumed by batch processing
-            i += max(1, context.blocks_consumed)
-
-        separator = "\n\n" if indent_level == 0 else "\n"
-        return separator.join(markdown_parts)

notionary/page/search_filter_builder.py

@@ -1,132 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any, Dict, Literal, Optional
-
-
-@dataclass
-class SearchConfig:
-    """Konfiguration für Notion Search API Filter."""
-
-    query: Optional[str] = None
-    object_type: Optional[Literal["page", "database"]] = None
-    sort_direction: Literal["ascending", "descending"] = "descending"
-    sort_timestamp: Literal["last_edited_time", "created_time"] = "last_edited_time"
-    page_size: int = 100
-    start_cursor: Optional[str] = None
-
-    def to_search_dict(self) -> Dict[str, Any]:
-        """Konvertiert zu einem Notion Search API Dictionary."""
-        search_dict = {}
-
-        if self.query:
-            search_dict["query"] = self.query
-
-        if self.object_type:
-            search_dict["filter"] = {"property": "object", "value": self.object_type}
-
-        search_dict["sort"] = {
-            "direction": self.sort_direction,
-            "timestamp": self.sort_timestamp,
-        }
-
-        search_dict["page_size"] = min(self.page_size, 100)
-
-        if self.start_cursor:
-            search_dict["start_cursor"] = self.start_cursor
-
-        return search_dict
-
-
-class SearchFilterBuilder:
-    """
-    Builder class for creating Notion Search API filters with comprehensive options.
-    """
-
-    def __init__(self, config: SearchConfig = None):
-        self.config = config or SearchConfig()
-
-    def with_query(self, query: str) -> SearchFilterBuilder:
-        """Set the search query string."""
-        self.config.query = query
-        return self
-
-    def with_pages_only(self) -> SearchFilterBuilder:
-        """Filter to only return pages."""
-        self.config.object_type = "page"
-        return self
-
-    def with_databases_only(self) -> SearchFilterBuilder:
-        """Filter to only return databases."""
-        self.config.object_type = "database"
-        return self
-
-    def with_sort_direction(
-        self, direction: Literal["ascending", "descending"]
-    ) -> SearchFilterBuilder:
-        """Set sort direction (ascending or descending)."""
-        self.config.sort_direction = direction
-        return self
-
-    def with_sort_ascending(self) -> SearchFilterBuilder:
-        """Sort results in ascending order."""
-        return self.with_sort_direction("ascending")
-
-    def with_sort_descending(self) -> SearchFilterBuilder:
-        """Sort results in descending order."""
-        return self.with_sort_direction("descending")
-
-    def with_sort_timestamp(
-        self, timestamp: Literal["last_edited_time", "created_time"]
-    ) -> SearchFilterBuilder:
-        """Set the timestamp field to sort by."""
-        self.config.sort_timestamp = timestamp
-        return self
-
-    def with_sort_by_created_time(self) -> SearchFilterBuilder:
-        """Sort by creation time."""
-        return self.with_sort_timestamp("created_time")
-
-    def with_sort_by_last_edited(self) -> SearchFilterBuilder:
-        """Sort by last edited time."""
-        return self.with_sort_timestamp("last_edited_time")
-
-    def with_page_size(self, size: int) -> SearchFilterBuilder:
-        """Set page size for pagination (max 100)."""
-        self.config.page_size = min(size, 100)
-        return self
-
-    def with_cursor(self, cursor: Optional[str]) -> SearchFilterBuilder:
-        """Set start cursor for pagination."""
-        self.config.start_cursor = cursor
-        return self
-
-    def without_cursor(self) -> SearchFilterBuilder:
-        """Remove start cursor (for first page)."""
-        self.config.start_cursor = None
-        return self
-
-    def build(self) -> Dict[str, Any]:
-        """Build the final search filter dictionary. Builder bleibt wiederverwendbar!"""
-        return self.config.to_search_dict()
-
-    def get_config(self) -> SearchConfig:
-        """Get the underlying SearchConfig."""
-        return self.config
-
-    def copy(self) -> SearchFilterBuilder:
-        """Create a copy of the builder."""
-        new_config = SearchConfig(
-            query=self.config.query,
-            object_type=self.config.object_type,
-            sort_direction=self.config.sort_direction,
-            sort_timestamp=self.config.sort_timestamp,
-            page_size=self.config.page_size,
-            start_cursor=self.config.start_cursor,
-        )
-        return SearchFilterBuilder(new_config)
-
-    def reset(self) -> SearchFilterBuilder:
-        """Reset all configurations to defaults."""
-        self.config = SearchConfig()
-        return self

notionary/page/utils.py

@@ -1,60 +0,0 @@
-from typing import Any
-
-
-def extract_property_value(prop_data: dict) -> Any:
-    """
-    Extract the value of a Notion property from its data dict.
-    Supports all common Notion property types.
-
-    Args:
-        prop_data: The property data dictionary from Notion API
-
-    Returns:
-        The extracted value based on property type
-    """
-    prop_type = prop_data.get("type")
-    if not prop_type:
-        return None
-
-    # Handler dictionary for different property types
-    handlers = {
-        "title": lambda: "".join(
-            t.get("plain_text", "") for t in prop_data.get("title", [])
-        ),
-        "rich_text": lambda: "".join(
-            t.get("plain_text", "") for t in prop_data.get("rich_text", [])
-        ),
-        "number": lambda: prop_data.get("number"),
-        "select": lambda: (
-            prop_data.get("select", {}).get("name") if prop_data.get("select") else None
-        ),
-        "multi_select": lambda: [
-            o.get("name") for o in prop_data.get("multi_select", [])
-        ],
-        "status": lambda: (
-            prop_data.get("status", {}).get("name") if prop_data.get("status") else None
-        ),
-        "date": lambda: prop_data.get("date"),
-        "checkbox": lambda: prop_data.get("checkbox"),
-        "url": lambda: prop_data.get("url"),
-        "email": lambda: prop_data.get("email"),
-        "phone_number": lambda: prop_data.get("phone_number"),
-        "people": lambda: [p.get("id") for p in prop_data.get("people", [])],
-        "files": lambda: [
-            (
-                f.get("external", {}).get("url")
-                if f.get("type") == "external"
-                else f.get("name")
-            )
-            for f in prop_data.get("files", [])
-        ],
-    }
-
-    handler = handlers.get(prop_type)
-    if handler is None:
-        return prop_data  # Return raw data if type unknown
-
-    try:
-        return handler()
-    except Exception:
-        return None  # Return None if extraction fails

notionary/page/writer/handler/__init__.py

@@ -1,24 +0,0 @@
-from .code_handler import CodeHandler
-from .column_handler import ColumnHandler
-from .column_list_handler import ColumnListHandler
-from .equation_handler import EquationHandler
-from .line_handler import LineHandler
-from .line_processing_context import LineProcessingContext, ParentBlockContext
-from .regular_line_handler import RegularLineHandler
-from .table_handler import TableHandler
-from .toggle_handler import ToggleHandler
-from .toggleable_heading_handler import ToggleableHeadingHandler
-
-__all__ = [
-    "LineProcessingContext",
-    "ParentBlockContext",
-    "LineHandler",
-    "ColumnListHandler",
-    "ColumnHandler",
-    "ToggleableHeadingHandler",
-    "ToggleHandler",
-    "TableHandler",
-    "RegularLineHandler",
-    "CodeHandler",
-    "EquationHandler",
-]

notionary/page/writer/handler/code_handler.py

@@ -1,72 +0,0 @@
-import re
-
-from notionary.blocks.code.code_element import CodeElement
-from notionary.page.writer.handler.line_handler import (
-    LineHandler,
-    LineProcessingContext,
-)
-
-
-class CodeHandler(LineHandler):
-    """Handles code block specific logic with batching.
-
-    Markdown syntax:
-    ```language "optional caption"
-    code lines...
-    ```
-    """
-
-    def __init__(self):
-        super().__init__()
-        self._code_start_pattern = re.compile(r"^```(\w*)\s*(?:\"([^\"]*)\")?\s*$")
-        self._code_end_pattern = re.compile(r"^```\s*$")
-
-    def _can_handle(self, context: LineProcessingContext) -> bool:
-        if self._is_inside_parent_context(context):
-            return False
-        return self._is_code_start(context)
-
-    async def _process(self, context: LineProcessingContext) -> None:
-        if self._is_code_start(context):
-            await self._process_complete_code_block(context)
-            self._mark_processed(context)
-
-    def _is_code_start(self, context: LineProcessingContext) -> bool:
-        """Check if this line starts a code block."""
-        return self._code_start_pattern.match(context.line.strip()) is not None
-
-    def _is_inside_parent_context(self, context: LineProcessingContext) -> bool:
-        """Check if we're currently inside any parent context (toggle, heading, etc.)."""
-        return len(context.parent_stack) > 0
-
-    async def _process_complete_code_block(
-        self, context: LineProcessingContext
-    ) -> None:
-        """Process the entire code block in one go using CodeElement."""
-        code_lines, lines_to_consume = self._collect_code_lines(context)
-
-        block = CodeElement.create_from_markdown_block(
-            opening_line=context.line, code_lines=code_lines
-        )
-
-        if block:
-            context.lines_consumed = lines_to_consume
-            context.result_blocks.append(block)
-
-    def _collect_code_lines(
-        self, context: LineProcessingContext
-    ) -> tuple[list[str], int]:
-        """Collect lines until closing fence and return (lines, count_to_consume)."""
-        lines = []
-        for idx, ln in enumerate(context.get_remaining_lines()):
-            if self._code_end_pattern.match(ln.strip()):
-                return lines, idx + 1
-            lines.append(ln)
-        # No closing fence: consume all remaining
-        rem = context.get_remaining_lines()
-        return rem, len(rem)
-
-    def _mark_processed(self, context: LineProcessingContext) -> None:
-        """Mark context as processed and continue."""
-        context.was_processed = True
-        context.should_continue = True