notionary 0.2.18__py3-none-any.whl → 0.2.21__py3-none-any.whl

notionary/models/notion_block_response.py

@@ -1,264 +0,0 @@
-from typing import List, Optional, Union, Literal
-from pydantic import BaseModel
-
-
-# Rich Text Komponenten
-class TextContent(BaseModel):
-    content: str
-    link: Optional[dict] = None
-
-
-class Annotations(BaseModel):
-    bold: bool
-    italic: bool
-    strikethrough: bool
-    underline: bool
-    code: bool
-    color: str
-
-
-class RichText(BaseModel):
-    type: Literal["text"]
-    text: TextContent
-    annotations: Annotations
-    plain_text: str
-    href: Optional[str]
-
-
-# Benutzerobjekt
-class User(BaseModel):
-    object: str
-    id: str
-
-
-# Elternobjekte
-class PageParent(BaseModel):
-    type: Literal["page_id"]
-    page_id: str
-
-
-class DatabaseParent(BaseModel):
-    type: Literal["database_id"]
-    database_id: str
-
-
-class WorkspaceParent(BaseModel):
-    type: Literal["workspace"]
-    workspace: bool = True
-
-
-Parent = Union[PageParent, DatabaseParent, WorkspaceParent]
-
-
-# Block-spezifische Inhalte
-class ParagraphBlock(BaseModel):
-    rich_text: List[RichText]
-    color: Optional[str] = "default"
-
-
-class Heading1Block(BaseModel):
-    rich_text: List[RichText]
-    color: Optional[str] = "default"
-    is_toggleable: Optional[bool] = False
-
-
-class Heading2Block(BaseModel):
-    rich_text: List[RichText]
-    color: Optional[str] = "default"
-    is_toggleable: Optional[bool] = False
-
-
-class Heading3Block(BaseModel):
-    rich_text: List[RichText]
-    color: Optional[str] = "default"
-    is_toggleable: Optional[bool] = False
-
-
-class BulletedListItemBlock(BaseModel):
-    rich_text: List[RichText]
-    color: Optional[str] = "default"
-
-
-class NumberedListItemBlock(BaseModel):
-    rich_text: List[RichText]
-    color: Optional[str] = "default"
-
-
-class ToDoBlock(BaseModel):
-    rich_text: List[RichText]
-    checked: Optional[bool] = False
-    color: Optional[str] = "default"
-
-
-class ToggleBlock(BaseModel):
-    rich_text: List[RichText]
-    color: Optional[str] = "default"
-
-
-class QuoteBlock(BaseModel):
-    rich_text: List[RichText]
-    color: Optional[str] = "default"
-
-
-class CalloutBlock(BaseModel):
-    rich_text: List[RichText]
-    icon: Optional[dict] = None
-    color: Optional[str] = "default"
-
-
-class CodeBlock(BaseModel):
-    rich_text: List[RichText]
-    language: Optional[str] = "plain text"
-
-
-class EquationBlock(BaseModel):
-    expression: str
-
-
-class DividerBlock(BaseModel):
-    pass
-
-
-class TableOfContentsBlock(BaseModel):
-    color: Optional[str] = "default"
-
-
-class BreadcrumbBlock(BaseModel):
-    pass
-
-
-class ColumnListBlock(BaseModel):
-    pass
-
-
-class ColumnBlock(BaseModel):
-    pass
-
-
-class LinkToPageBlock(BaseModel):
-    type: str
-    page_id: Optional[str] = None
-    database_id: Optional[str] = None
-
-
-class SyncedBlock(BaseModel):
-    synced_from: Optional[dict] = None
-
-
-class TemplateBlock(BaseModel):
-    rich_text: List[RichText]
-
-
-class TableBlock(BaseModel):
-    table_width: int
-    has_column_header: bool
-    has_row_header: bool
-
-
-class TableRowBlock(BaseModel):
-    cells: List[List[RichText]]
-
-
-class BookmarkBlock(BaseModel):
-    caption: List[RichText]
-    url: str
-
-
-class EmbedBlock(BaseModel):
-    url: str
-
-
-class ImageBlock(BaseModel):
-    type: str
-    external: Optional[dict] = None
-    file: Optional[dict] = None
-    caption: List[RichText]
-
-
-class VideoBlock(BaseModel):
-    type: str
-    external: Optional[dict] = None
-    file: Optional[dict] = None
-    caption: List[RichText]
-
-
-class PDFBlock(BaseModel):
-    type: str
-    external: Optional[dict] = None
-    file: Optional[dict] = None
-    caption: List[RichText]
-
-
-class FileBlock(BaseModel):
-    type: str
-    external: Optional[dict] = None
-    file: Optional[dict] = None
-    caption: List[RichText]
-
-
-class AudioBlock(BaseModel):
-    type: str
-    external: Optional[dict] = None
-    file: Optional[dict] = None
-    caption: List[RichText]
-
-
-class LinkPreviewBlock(BaseModel):
-    url: str
-
-
-class ChildPageBlock(BaseModel):
-    title: str
-
-
-class ChildDatabaseBlock(BaseModel):
-    title: str
-
-
-# TODO: Use the block typing here:
-# Test the code base.
-class Block(BaseModel):
-    object: Literal["block"]
-    id: str
-    parent: Parent
-    created_time: str
-    last_edited_time: str
-    created_by: User
-    last_edited_by: User
-    has_children: bool
-    archived: bool
-    in_trash: bool
-    type: str
-    paragraph: Optional[ParagraphBlock] = None
-    heading_1: Optional[Heading1Block] = None
-    heading_2: Optional[Heading2Block] = None
-    heading_3: Optional[Heading3Block] = None
-    bulleted_list_item: Optional[BulletedListItemBlock] = None
-    numbered_list_item: Optional[NumberedListItemBlock] = None
-    to_do: Optional[ToDoBlock] = None
-    toggle: Optional[ToggleBlock] = None
-    quote: Optional[QuoteBlock] = None
-    callout: Optional[CalloutBlock] = None
-    code: Optional[CodeBlock] = None
-    equation: Optional[EquationBlock] = None
-    divider: Optional[DividerBlock] = None
-    table_of_contents: Optional[TableOfContentsBlock] = None
-    breadcrumb: Optional[BreadcrumbBlock] = None
-    column_list: Optional[ColumnListBlock] = None
-    column: Optional[ColumnBlock] = None
-    link_to_page: Optional[LinkToPageBlock] = None
-    synced_block: Optional[SyncedBlock] = None
-    template: Optional[TemplateBlock] = None
-    table: Optional[TableBlock] = None
-    table_row: Optional[TableRowBlock] = None
-    bookmark: Optional[BookmarkBlock] = None
-    embed: Optional[EmbedBlock] = None
-    image: Optional[ImageBlock] = None
-    video: Optional[VideoBlock] = None
-    pdf: Optional[PDFBlock] = None
-    file: Optional[FileBlock] = None
-    audio: Optional[AudioBlock] = None
-    link_preview: Optional[LinkPreviewBlock] = None
-    child_page: Optional[ChildPageBlock] = None
-    child_database: Optional[ChildDatabaseBlock] = None
-    unsupported: Optional[dict] = None

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/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,52 +0,0 @@
-from typing import Any, Dict, Optional
-
-from notionary.blocks.registry.block_registry import BlockRegistry
-
-from notionary.blocks import NotionBlockClient
-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()
-        return self._notion_to_markdown_converter.convert(blocks)
-
-    async def _get_page_blocks_with_children(
-        self, parent_id: Optional[str] = None
-    ) -> list[Dict[str, Any]]:
-        blocks = (
-            await self.client.get_page_blocks(page_id=self.page_id)
-            if parent_id is None
-            else await self.client.get_block_children(parent_id)
-        )
-
-        if not blocks:
-            return []
-
-        for block in blocks:
-            if not block.get("has_children"):
-                continue
-
-            block_id = block.get("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))