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

notionary/page/markdown_whitespace_processor.py

@@ -1,129 +0,0 @@
-"""
-Markdown whitespace processing utilities.
-
-Handles normalization of markdown text while preserving code blocks and their indentation.
-"""
-
-from typing import Tuple
-
-
-class MarkdownWhitespaceProcessor:
-    """
-    Processes markdown text to normalize whitespace while preserving code block formatting.
-
-    This processor handles:
-    - Removing leading whitespace from regular lines
-    - Preserving code block structure and indentation
-    - Normalizing code block markers
-    """
-
-    @staticmethod
-    def process_markdown_whitespace(markdown_text: str) -> str:
-        """Process markdown text to normalize whitespace while preserving code blocks."""
-        lines = markdown_text.split("\n")
-        if not lines:
-            return ""
-
-        return MarkdownWhitespaceProcessor._process_whitespace_lines(lines)
-
-    @staticmethod
-    def _process_whitespace_lines(lines: list[str]) -> str:
-        """Process all lines and return the processed markdown."""
-        processed_lines = []
-        in_code_block = False
-        current_code_block = []
-
-        for line in lines:
-            processed_lines, in_code_block, current_code_block = (
-                MarkdownWhitespaceProcessor._process_single_line(
-                    line, processed_lines, in_code_block, current_code_block
-                )
-            )
-
-        return "\n".join(processed_lines)
-
-    @staticmethod
-    def _process_single_line(
-        line: str,
-        processed_lines: list[str],
-        in_code_block: bool,
-        current_code_block: list[str],
-    ) -> Tuple[list[str], bool, list[str]]:
-        """Process a single line and return updated state."""
-        if MarkdownWhitespaceProcessor._is_code_block_marker(line):
-            return MarkdownWhitespaceProcessor._handle_code_block_marker(
-                line, processed_lines, in_code_block, current_code_block
-            )
-        if in_code_block:
-            current_code_block.append(line)
-            return processed_lines, in_code_block, current_code_block
-        else:
-            processed_lines.append(line.lstrip())
-            return processed_lines, in_code_block, current_code_block
-
-    @staticmethod
-    def _handle_code_block_marker(
-        line: str,
-        processed_lines: list[str],
-        in_code_block: bool,
-        current_code_block: list[str],
-    ) -> Tuple[list[str], bool, list[str]]:
-        """Handle code block start/end markers."""
-        if not in_code_block:
-            return MarkdownWhitespaceProcessor._start_code_block(line, processed_lines)
-        else:
-            return MarkdownWhitespaceProcessor._end_code_block(
-                processed_lines, current_code_block
-            )
-
-    @staticmethod
-    def _start_code_block(
-        line: str, processed_lines: list[str]
-    ) -> Tuple[list[str], bool, list[str]]:
-        """Start a new code block."""
-        processed_lines.append(
-            MarkdownWhitespaceProcessor._normalize_code_block_start(line)
-        )
-        return processed_lines, True, []
-
-    @staticmethod
-    def _end_code_block(
-        processed_lines: list[str], current_code_block: list[str]
-    ) -> Tuple[list[str], bool, list[str]]:
-        """End the current code block."""
-        processed_lines.extend(
-            MarkdownWhitespaceProcessor._normalize_code_block_content(
-                current_code_block
-            )
-        )
-        processed_lines.append("```")
-        return processed_lines, False, []
-
-    @staticmethod
-    def _is_code_block_marker(line: str) -> bool:
-        """Check if line is a code block marker."""
-        return line.lstrip().startswith("```")
-
-    @staticmethod
-    def _normalize_code_block_start(line: str) -> str:
-        """Normalize code block opening marker."""
-        language = line.lstrip().replace("```", "", 1).strip()
-        return "```" + language
-
-    @staticmethod
-    def _normalize_code_block_content(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/models.py

@@ -1,322 +0,0 @@
-from typing import Any, Literal, Optional, Union
-
-from pydantic import BaseModel, ConfigDict
-
-from notionary.blocks.models import ParentObject
-
-
-class TextContent(BaseModel):
-    content: str
-    link: Optional[str] = None
-
-
-class RichText(BaseModel):
-    type: str
-    text: TextContent
-    plain_text: str
-    href: Optional[str] = None
-
-
-class User(BaseModel):
-    object: str
-    id: str
-
-
-class Parent(BaseModel):
-    type: Literal["page_id", "workspace", "block_id", "database_id"]
-    page_id: Optional[str] = None
-    block_id: Optional[str] = None
-    database_id: Optional[str] = None
-
-
-# Rich text types for Pydantic models
-class TextContentPydantic(BaseModel):
-    content: str
-    link: Optional[dict[str, str]] = None
-
-
-class Annotations(BaseModel):
-    bold: bool
-    italic: bool
-    strikethrough: bool
-    underline: bool
-    code: bool
-    color: str
-
-
-class RichTextItemPydantic(BaseModel):
-    type: str  # 'text', 'mention', 'equation'
-    text: Optional[TextContentPydantic] = None
-    annotations: Annotations
-    plain_text: str
-    href: Optional[str] = None
-
-
-# Cover and Icon types
-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]
-
-
-# Database property schema types (these are schema definitions, not values)
-class StatusOption(BaseModel):
-    id: str
-    name: str
-    color: str
-    description: Optional[str] = None
-
-
-class StatusGroup(BaseModel):
-    id: str
-    name: str
-    color: str
-    option_ids: list[str]
-
-
-class StatusPropertySchema(BaseModel):
-    options: list[StatusOption]
-    groups: list[StatusGroup]
-
-
-class DatabaseStatusProperty(BaseModel):
-    id: str
-    name: str
-    type: Literal["status"]
-    status: StatusPropertySchema
-
-
-class RelationPropertySchema(BaseModel):
-    database_id: str
-    type: str  # "single_property"
-    single_property: dict[str, Any]
-
-
-class DatabaseRelationProperty(BaseModel):
-    id: str
-    name: str
-    type: Literal["relation"]
-    relation: RelationPropertySchema
-
-
-class DatabaseUrlProperty(BaseModel):
-    id: str
-    name: str
-    type: Literal["url"]
-    url: dict[str, Any]  # Usually empty dict
-
-
-class DatabaseRichTextProperty(BaseModel):
-    id: str
-    name: str
-    type: Literal["rich_text"]
-    rich_text: dict[str, Any]  # Usually empty dict
-
-
-class MultiSelectOption(BaseModel):
-    id: str
-    name: str
-    color: str
-    description: Optional[str] = None
-
-
-class MultiSelectPropertySchema(BaseModel):
-    options: list[MultiSelectOption]
-
-
-class DatabaseMultiSelectProperty(BaseModel):
-    id: str
-    name: str
-    type: Literal["multi_select"]
-    multi_select: MultiSelectPropertySchema
-
-
-class DatabaseTitleProperty(BaseModel):
-    id: str
-    name: str
-    type: Literal["title"]
-    title: dict[str, Any]  # Usually empty dict
-
-
-# Generic database property for unknown types
-class GenericDatabaseProperty(BaseModel):
-    id: str
-    name: str
-    type: str
-
-    model_config = ConfigDict(extra="allow")
-
-
-# Union of all database property types
-DatabaseProperty = Union[
-    DatabaseStatusProperty,
-    DatabaseRelationProperty,
-    DatabaseUrlProperty,
-    DatabaseRichTextProperty,
-    DatabaseMultiSelectProperty,
-    DatabaseTitleProperty,
-    GenericDatabaseProperty,
-]
-
-
-# Page property value types (these are actual values, not schemas)
-class StatusValue(BaseModel):
-    id: str
-    name: str
-    color: str
-
-
-class StatusProperty(BaseModel):
-    id: str
-    type: str  # 'status'
-    status: Optional[StatusValue] = None
-
-
-class RelationItem(BaseModel):
-    id: str
-
-
-class RelationProperty(BaseModel):
-    id: str
-    type: str  # 'relation'
-    relation: list[RelationItem]
-    has_more: bool
-
-
-class UrlProperty(BaseModel):
-    id: str
-    type: str  # 'url'
-    url: Optional[str] = None
-
-
-class RichTextProperty(BaseModel):
-    id: str
-    type: str  # 'rich_text'
-    rich_text: list[RichTextItemPydantic]
-
-
-class MultiSelectItem(BaseModel):
-    id: str
-    name: str
-    color: str
-
-
-class MultiSelectProperty(BaseModel):
-    id: str
-    type: str  # 'multi_select'
-    multi_select: list[MultiSelectItem]
-
-
-class TitleProperty(BaseModel):
-    id: str
-    type: str  # 'title'
-    title: list[RichTextItemPydantic]
-
-
-# Cover types
-class ExternalCover(BaseModel):
-    url: str
-
-
-class NotionCover(BaseModel):
-    type: str  # 'external', 'file'
-    external: Optional[ExternalCover] = None
-
-
-# User type for Pydantic
-class NotionUser(BaseModel):
-    object: str  # 'user'
-    id: str
-
-
-# Database object
-class NotionDatabaseResponse(BaseModel):
-    """
-    Represents the response from the Notion API when retrieving a database.
-    """
-
-    object: Literal["database"]
-    id: str
-    cover: Optional[Cover] = None
-    icon: Optional[Icon] = None
-    created_time: str
-    last_edited_time: str
-    created_by: NotionUser
-    last_edited_by: NotionUser
-    title: list[RichTextItemPydantic]
-    description: list[Any]
-    is_inline: bool
-    properties: dict[
-        str, Any
-    ]  # Using Any for flexibility with different property schemas
-    parent: ParentObject
-    url: str
-    public_url: Optional[str] = None
-    archived: bool
-    in_trash: bool
-
-
-class NotionPageResponse(BaseModel):
-    object: Literal["page"]
-    id: str
-    created_time: str
-    last_edited_time: str
-    created_by: NotionUser
-    last_edited_by: NotionUser
-    cover: Optional[NotionCover] = None
-    icon: Optional[Icon] = None
-    parent: ParentObject
-    archived: bool
-    in_trash: bool
-    properties: dict[str, Any]
-    url: str
-    public_url: Optional[str] = None
-
-
-# Specific response type for database queries (pages only)
-class NotionQueryDatabaseResponse(BaseModel):
-    """
-    Notion database query response model for querying pages within a database.
-    """
-
-    object: Literal["list"]
-    results: list[NotionPageResponse]
-    next_cursor: Optional[str] = None
-    has_more: bool
-    type: Literal["page_or_database"]
-    page_or_database: dict[str, Any]
-    request_id: str
-
-
-class NotionDatabaseSearchResponse(BaseModel):
-    """
-    Notion search response model for database-only searches.
-    """
-
-    object: Literal["list"]
-    results: list[NotionDatabaseResponse]
-    next_cursor: Optional[str] = None
-    has_more: bool
-    type: Literal["page_or_database"]
-    page_or_database: dict[str, Any]
-    request_id: str