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

notionary/models/notion_page_response.py

@@ -1,78 +0,0 @@
-from typing import Literal, Optional, Dict, Any, Union
-
-from pydantic import BaseModel
-
-
-class User(BaseModel):
-    """Represents a Notion user object."""
-
-    object: str
-    id: str
-
-
-class ExternalFile(BaseModel):
-    """Represents an external file, e.g., for cover images."""
-
-    url: str
-
-
-class Cover(BaseModel):
-    """Cover image for a Notion page."""
-
-    type: str
-    external: ExternalFile
-
-
-class EmojiIcon(BaseModel):
-    type: Literal["emoji"]
-    emoji: str
-
-
-class ExternalIcon(BaseModel):
-    type: Literal["external"]
-    external: ExternalFile
-
-
-Icon = Union[EmojiIcon, ExternalIcon]
-
-
-class DatabaseParent(BaseModel):
-    type: Literal["database_id"]
-    database_id: str
-
-
-class PageParent(BaseModel):
-    type: Literal["page_id"]
-    page_id: str
-
-
-class WorkspaceParent(BaseModel):
-    type: Literal["workspace"]
-    workspace: bool = True
-
-
-Parent = Union[DatabaseParent, PageParent, WorkspaceParent]
-
-
-class NotionPageResponse(BaseModel):
-    """
-    Represents a full Notion page object as returned by the Notion API.
-
-    This structure is flexible and designed to work with different database schemas.
-    """
-
-    object: str
-    id: str
-    created_time: str
-    last_edited_time: str
-    created_by: User
-    last_edited_by: User
-    cover: Optional[Cover]
-    icon: Optional[Icon]
-    parent: Parent
-    archived: bool
-    in_trash: bool
-    properties: Dict[str, Any]
-    url: str
-    public_url: Optional[str]
-    request_id: str

notionary/page/content/markdown_whitespace_processor.py

@@ -1,80 +0,0 @@
-class MarkdownWhitespaceProcessor:
-    """Helper class for processing markdown whitespace."""
-
-    def __init__(self):
-        self.processed_lines = []
-        self.in_code_block = False
-        self.current_code_block = []
-
-    def process_lines(self, lines: list[str]) -> str:
-        """Process all lines and return the processed markdown."""
-        self.processed_lines = []
-        self.in_code_block = False
-        self.current_code_block = []
-
-        for line in lines:
-            self._process_single_line(line)
-
-        # Handle unclosed code block
-        if self.in_code_block and self.current_code_block:
-            self._finish_code_block()
-
-        return "\n".join(self.processed_lines)
-
-    def _process_single_line(self, line: str) -> None:
-        """Process a single line of markdown."""
-        if self._is_code_block_marker(line):
-            self._handle_code_block_marker(line)
-            return
-
-        if self.in_code_block:
-            self.current_code_block.append(line)
-            return
-
-        # Regular text - remove leading whitespace
-        self.processed_lines.append(line.lstrip())
-
-    def _handle_code_block_marker(self, line: str) -> None:
-        """Handle code block start/end markers."""
-        if not self.in_code_block:
-            # Starting new code block
-            self.in_code_block = True
-            self.processed_lines.append(self._normalize_code_block_start(line))
-            self.current_code_block = []
-        else:
-            # Ending code block
-            self._finish_code_block()
-
-    def _finish_code_block(self) -> None:
-        """Finish processing current code block."""
-        self.processed_lines.extend(
-            self._normalize_code_block_content(self.current_code_block)
-        )
-        self.processed_lines.append("```")
-        self.in_code_block = False
-
-    def _is_code_block_marker(self, line: str) -> bool:
-        """Check if line is a code block marker."""
-        return line.lstrip().startswith("```")
-
-    def _normalize_code_block_start(self, line: str) -> str:
-        """Normalize code block opening marker."""
-        language = line.lstrip().replace("```", "", 1).strip()
-        return "```" + language
-
-    def _normalize_code_block_content(self, code_lines: list[str]) -> list[str]:
-        """Normalize code block indentation."""
-        if not code_lines:
-            return []
-
-        # Find minimum indentation from non-empty lines
-        non_empty_lines = [line for line in code_lines if line.strip()]
-        if not non_empty_lines:
-            return [""] * len(code_lines)
-
-        min_indent = min(len(line) - len(line.lstrip()) for line in non_empty_lines)
-        if min_indent == 0:
-            return code_lines
-
-        # Remove common indentation
-        return ["" if not line.strip() else line[min_indent:] for line in code_lines]

notionary/page/content/notion_text_length_utils.py

@@ -1,87 +0,0 @@
-"""
-Utility functions for handling Notion API text length limitations.
-
-This module provides functions to fix text content that exceeds Notion's
-rich_text character limit of 2000 characters per element.
-
-Resolves API errors like:
-"validation_error - body.children[79].toggle.children[2].paragraph.rich_text[0].text.content.length
-should be ≤ 2000, instead was 2162."
-"""
-
-import re
-import logging
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-def fix_blocks_content_length(
-    blocks: list[dict[str, Any]], max_text_length: int = 1900
-) -> list[dict[str, Any]]:
-    """Check each block and ensure text content doesn't exceed Notion's limit."""
-    return [_fix_single_block_content(block, max_text_length) for block in blocks]
-
-
-def _fix_single_block_content(
-    block: dict[str, Any], max_text_length: int
-) -> dict[str, Any]:
-    """Fix content length in a single block and its children recursively."""
-    block_copy = block.copy()
-
-    block_type = block.get("type")
-    if not block_type:
-        return block_copy
-
-    content = block.get(block_type)
-    if not content:
-        return block_copy
-
-    if "rich_text" in content:
-        _fix_rich_text_content(block_copy, block_type, content, max_text_length)
-
-    if "children" in content and content["children"]:
-        block_copy[block_type]["children"] = [
-            _fix_single_block_content(child, max_text_length)
-            for child in content["children"]
-        ]
-
-    return block_copy
-
-
-def _fix_rich_text_content(
-    block_copy: dict[str, Any],
-    block_type: str,
-    content: dict[str, Any],
-    max_text_length: int,
-) -> None:
-    """Fix rich text content that exceeds the length limit."""
-    rich_text = content["rich_text"]
-    for i, text_item in enumerate(rich_text):
-        if "text" not in text_item or "content" not in text_item["text"]:
-            continue
-
-        text_content = text_item["text"]["content"]
-        if len(text_content) <= max_text_length:
-            continue
-
-        logger.warning(
-            "Truncating text content from %d to %d chars",
-            len(text_content),
-            max_text_length,
-        )
-        block_copy[block_type]["rich_text"][i]["text"]["content"] = text_content[
-            :max_text_length
-        ]
-
-
-def split_to_paragraphs(markdown_text: str) -> list[str]:
-    """Split markdown into paragraphs."""
-    paragraphs = re.split(r"\n\s*\n", markdown_text)
-    return [p for p in paragraphs if p.strip()]
-
-
-def split_to_sentences(paragraph: str) -> list[str]:
-    """Split a paragraph into sentences."""
-    sentences = re.split(r"(?<=[.!?])\s+", paragraph)
-    return [s for s in sentences if s.strip()]

notionary/page/content/page_content_retriever.py

@@ -1,60 +0,0 @@
-import json
-from typing import Any, Dict, Optional
-
-from notionary.blocks.registry.block_registry import BlockRegistry
-
-from notionary.blocks import NotionBlockClient
-from notionary.blocks.shared.models import Block
-from notionary.page.notion_to_markdown_converter import (
-    NotionToMarkdownConverter,
-)
-from notionary.util import LoggingMixin
-
-
-class PageContentRetriever(LoggingMixin):
-    def __init__(
-        self,
-        page_id: str,
-        block_registry: BlockRegistry,
-    ):
-        self.page_id = page_id
-        self._notion_to_markdown_converter = NotionToMarkdownConverter(
-            block_registry=block_registry
-        )
-        self.client = NotionBlockClient()
-
-    async def get_page_content(self) -> str:
-        blocks = await self._get_page_blocks_with_children()
-
-        # TODO: Fix this quick fix🧯 Quick-Fix: Konvertiere rekursive Block-Objekte in plain dicts
-        blocks_as_dicts = [block.model_dump(mode="python", exclude_unset=True) for block in blocks]
-
-        return self._notion_to_markdown_converter.convert(blocks_as_dicts)
-
-    async def _get_page_blocks_with_children(
-        self, parent_id: Optional[str] = None
-    ) -> list[Block]:
-        response = (
-            await self.client.get_block_children(block_id=self.page_id)
-            if parent_id is None
-            else await self.client.get_block_children(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_page_blocks_with_children(block_id)
-            if children:
-                block.children = children
-
-        return blocks

notionary/page/formatting/line_processor.py

@@ -1,153 +0,0 @@
-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))

notionary/page/formatting/markdown_to_notion_converter.py

@@ -1,153 +0,0 @@
-from notionary.blocks import ColumnElement, BlockRegistry
-from notionary.page.formatting.line_processor import LineProcessor
-
-# TODO: Hier rekursiven Baum Parser verwenden!
-class MarkdownToNotionConverter:
-    """Clean converter focused on block identification and conversion"""
-
-    def __init__(self, block_registry: BlockRegistry):
-        self._block_registry = block_registry
-        self._pipe_content_pattern = r"^\|\s?(.*)$"
-        self._toggle_element_types = ["ToggleElement", "ToggleableHeadingElement"]
-
-        # Setup column element callback if available
-        if self._block_registry.contains(ColumnElement):
-            ColumnElement.set_converter_callback(self.convert)
-
-    def convert(self, markdown_text: str) -> list[dict[str, any]]:
-        """Convert markdown text to Notion API block format"""
-        if not markdown_text:
-            return []
-
-        # Main conversion pipeline
-        blocks_with_positions = self._identify_all_blocks(markdown_text)
-        blocks_with_positions.sort(key=lambda x: x[0])  # Sort by position
-
-        # Flatten blocks (some elements return lists of blocks)
-        result = []
-        for _, _, block in blocks_with_positions:
-            if isinstance(block, list):
-                result.extend(block)
-            else:
-                result.append(block)
-        return result
-
-    def _identify_all_blocks(
-        self, markdown_text: str
-    ) -> list[tuple[int, int, dict[str, any]]]:
-        """Main block identification pipeline"""
-        all_blocks = []
-
-        # 1. Process complex multiline blocks first (toggles, etc.)
-        toggleable_blocks = self._find_toggleable_blocks(markdown_text)
-        all_blocks.extend(toggleable_blocks)
-
-        # 2. Process other multiline blocks
-        multiline_blocks = self._find_multiline_blocks(markdown_text, toggleable_blocks)
-        all_blocks.extend(multiline_blocks)
-
-        # 3. Process remaining text line by line
-        processed_blocks = toggleable_blocks + multiline_blocks
-        line_blocks = self._process_remaining_lines(markdown_text, processed_blocks)
-        all_blocks.extend(line_blocks)
-
-        return all_blocks
-
-    def _find_toggleable_blocks(
-        self, text: str
-    ) -> list[tuple[int, int, dict[str, any]]]:
-        """Find all toggleable blocks (Toggle and ToggleableHeading)"""
-        toggleable_elements = self._get_elements_by_type(
-            self._toggle_element_types, multiline_only=True
-        )
-
-        blocks = []
-        for element in toggleable_elements:
-            matches = element.find_matches(text, self.convert, context_aware=True)
-            if matches:
-                blocks.extend(matches)
-
-        return blocks
-
-    def _find_multiline_blocks(
-        self, text: str, exclude_blocks: list[tuple[int, int, dict[str, any]]]
-    ) -> list[tuple[int, int, dict[str, any]]]:
-        """Find all multiline blocks except toggleable ones"""
-        multiline_elements = [
-            element
-            for element in self._block_registry.get_multiline_elements()
-            if element.__name__ not in self._toggle_element_types
-        ]
-
-        excluded_ranges = self._create_excluded_ranges(exclude_blocks)
-
-        blocks = []
-        for element in multiline_elements:
-            matches = element.find_matches(text)
-
-            for start_pos, end_pos, block in matches:
-                if not self._overlaps_with_ranges(start_pos, end_pos, excluded_ranges):
-                    # Handle multiple blocks from single element
-                    element_blocks = self._normalize_to_list(block)
-
-                    current_pos = start_pos
-                    for i, single_block in enumerate(element_blocks):
-                        blocks.append((current_pos, end_pos, single_block))
-                        # Increment position for subsequent blocks
-                        current_pos = end_pos + i + 1
-
-        return blocks
-
-    def _process_remaining_lines(
-        self, text: str, exclude_blocks: list[tuple[int, int, dict[str, any]]]
-    ) -> list[tuple[int, int, dict[str, any]]]:
-        """Process text line by line, excluding already processed ranges"""
-        if not text:
-            return []
-
-        excluded_ranges = self._create_excluded_ranges(exclude_blocks)
-        processor = LineProcessor(
-            block_registry=self._block_registry,
-            excluded_ranges=excluded_ranges,
-            pipe_pattern=self._pipe_content_pattern,
-        )
-
-        return processor.process_lines(text)
-
-    def _get_elements_by_type(
-        self, type_names: list[str], multiline_only: bool = False
-    ) -> list[any]:
-        """Get elements from registry by type names"""
-        elements = (
-            self._block_registry.get_multiline_elements()
-            if multiline_only
-            else self._block_registry.get_elements()
-        )
-
-        return [
-            element
-            for element in elements
-            if element.__name__ in type_names and hasattr(element, "match_markdown")
-        ]
-
-    def _create_excluded_ranges(
-        self, exclude_blocks: list[tuple[int, int, dict[str, any]]]
-    ) -> set[int]:
-        """Create set of excluded positions from block ranges"""
-        excluded_positions = set()
-        for start_pos, end_pos, _ in exclude_blocks:
-            excluded_positions.update(range(start_pos, end_pos + 1))
-        return excluded_positions
-
-    def _overlaps_with_ranges(
-        self, start_pos: int, end_pos: int, excluded_ranges: set[int]
-    ) -> bool:
-        """Check if a range overlaps with excluded positions"""
-        return any(pos in excluded_ranges for pos in range(start_pos, end_pos + 1))
-
-    @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]