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

notionary/blocks/shared/notion_block_element.py

@@ -1,37 +0,0 @@
-from typing import Optional, Any, TypeAlias, Union
-from abc import ABC
-
-from notionary.blocks.prompts.element_prompt_content import ElementPromptContent
-
-NotionBlock: TypeAlias = dict[str, Any]
-NotionBlockResult: TypeAlias = Optional[Union[list[dict[str, Any]], dict[str, Any]]]
-
-
-class NotionBlockElement(ABC):
-    """Base class for elements that can be converted between Markdown and Notion."""
-
-    @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown to Notion blocks (can return multiple blocks or single block)."""
-
-    @classmethod
-    def notion_to_markdown(cls, block: dict[str, any]) -> Optional[str]:
-        """Convert Notion block to markdown."""
-
-    @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if this element can handle the given markdown text."""
-        return bool(cls.markdown_to_notion(text))  # Now calls the class's version
-
-    @classmethod
-    def match_notion(cls, block: dict[str, any]) -> bool:
-        """Check if this element can handle the given Notion block."""
-        return bool(cls.notion_to_markdown(block))  # Now calls the class's version
-
-    @classmethod
-    def is_multiline(cls) -> bool:
-        return False
-
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """Returns a dictionary with information for LLM prompts about this element."""

notionary/blocks/shared/text_inline_formatter.py

@@ -1,262 +0,0 @@
-from typing import Any
-import re
-
-from notionary.blocks import ElementPromptBuilder, ElementPromptContent
-
-
-class TextInlineFormatter:
-    """
-    Handles conversion between Markdown inline formatting and Notion rich text elements.
-
-    Supports various formatting options:
-    - Bold: **text**
-    - Italic: *text* or _text_
-    - Underline: __text__
-    - Strikethrough: ~~text~~
-    - Code: `text`
-    - Links: [text](url)
-    """
-
-    # Format patterns for matching Markdown formatting
-    FORMAT_PATTERNS = [
-        (r"\*\*(.+?)\*\*", {"bold": True}),
-        (r"\*(.+?)\*", {"italic": True}),
-        (r"_(.+?)_", {"italic": True}),
-        (r"__(.+?)__", {"underline": True}),
-        (r"~~(.+?)~~", {"strikethrough": True}),
-        (r"`(.+?)`", {"code": True}),
-        (r"\[(.+?)\]\((.+?)\)", {"link": True}),
-        (r"@\[([0-9a-f-]+)\]", {"mention": True}),
-    ]
-
-    @classmethod
-    def parse_inline_formatting(cls, text: str) -> list[dict[str, Any]]:
-        """
-        Parse inline text formatting into Notion rich_text format.
-
-        Args:
-            text: Markdown text with inline formatting
-
-        Returns:
-            list of Notion rich_text objects
-        """
-        if not text:
-            return []
-
-        return cls._split_text_into_segments(text, cls.FORMAT_PATTERNS)
-
-    @classmethod
-    def _split_text_into_segments(
-        cls, text: str, format_patterns: list[tuple]
-    ) -> list[dict[str, Any]]:
-        """
-        Split text into segments by formatting markers and convert to Notion rich_text format.
-
-        Args:
-            text: Text to split
-            format_patterns: list of (regex pattern, formatting dict) tuples
-
-        Returns:
-            list of Notion rich_text objects
-        """
-        segments = []
-        remaining_text = text
-
-        while remaining_text:
-            earliest_match = None
-            earliest_format = None
-            earliest_pos = len(remaining_text)
-
-            # Find the earliest formatting marker
-            for pattern, formatting in format_patterns:
-                match = re.search(pattern, remaining_text)
-                if match and match.start() < earliest_pos:
-                    earliest_match = match
-                    earliest_format = formatting
-                    earliest_pos = match.start()
-
-            if earliest_match is None:
-                if remaining_text:
-                    segments.append(cls._create_text_element(remaining_text, {}))
-                break
-
-            if earliest_pos > 0:
-                segments.append(
-                    cls._create_text_element(remaining_text[:earliest_pos], {})
-                )
-
-            if "link" in earliest_format:
-                content = earliest_match.group(1)
-                url = earliest_match.group(2)
-                segments.append(cls._create_link_element(content, url))
-
-            elif "mention" in earliest_format:
-                id = earliest_match.group(1)
-                segments.append(cls._create_mention_element(id))
-
-            else:
-                content = earliest_match.group(1)
-                segments.append(cls._create_text_element(content, earliest_format))
-
-            # Move past the processed segment
-            remaining_text = remaining_text[
-                earliest_pos + len(earliest_match.group(0)) :
-            ]
-
-        return segments
-
-    @classmethod
-    def _create_text_element(
-        cls, text: str, formatting: dict[str, Any]
-    ) -> dict[str, Any]:
-        """
-        Create a Notion text element with formatting.
-
-        Args:
-            text: The text content
-            formatting: Dictionary of formatting options
-
-        Returns:
-            Notion rich_text element
-        """
-        annotations = cls._default_annotations()
-
-        # Apply formatting
-        for key, value in formatting.items():
-            if key == "color":
-                annotations["color"] = value
-            elif key in annotations:
-                annotations[key] = value
-
-        return {
-            "type": "text",
-            "text": {"content": text},
-            "annotations": annotations,
-            "plain_text": text,
-        }
-
-    @classmethod
-    def _create_link_element(cls, text: str, url: str) -> dict[str, Any]:
-        """
-        Create a Notion link element.
-
-        Args:
-            text: The link text
-            url: The URL
-
-        Returns:
-            Notion rich_text element with link
-        """
-        return {
-            "type": "text",
-            "text": {"content": text, "link": {"url": url}},
-            "annotations": cls._default_annotations(),
-            "plain_text": text,
-        }
-
-    @classmethod
-    def _create_mention_element(cls, id: str) -> dict[str, Any]:
-        """
-        Create a Notion mention element.
-
-        Args:
-            id: The page ID
-
-        Returns:
-            Notion rich_text element with mention
-        """
-        return {
-            "type": "mention",
-            "mention": {"type": "page", "page": {"id": id}},
-            "annotations": cls._default_annotations(),
-        }
-
-    @classmethod
-    def extract_text_with_formatting(cls, rich_text: list[dict[str, Any]]) -> str:
-        """
-        Convert Notion rich_text elements back to Markdown formatted text.
-
-        Args:
-            rich_text: list of Notion rich_text elements
-
-        Returns:
-            Markdown formatted text
-        """
-        formatted_parts = []
-
-        for text_obj in rich_text:
-            # Fallback: If plain_text is missing, use text['content']
-            content = text_obj.get("plain_text")
-            if content is None:
-                content = text_obj.get("text", {}).get("content", "")
-
-            annotations = text_obj.get("annotations", {})
-
-            if annotations.get("code", False):
-                content = f"`{content}`"
-            if annotations.get("strikethrough", False):
-                content = f"~~{content}~~"
-            if annotations.get("underline", False):
-                content = f"__{content}__"
-            if annotations.get("italic", False):
-                content = f"*{content}*"
-            if annotations.get("bold", False):
-                content = f"**{content}**"
-
-            text_data = text_obj.get("text", {})
-            link_data = text_data.get("link")
-            if link_data:
-                url = link_data.get("url", "")
-                content = f"[{content}]({url})"
-
-            formatted_parts.append(content)
-
-        return "".join(formatted_parts)
-
-    @classmethod
-    def _default_annotations(cls) -> dict[str, bool]:
-        """
-        Create default annotations object.
-
-        Returns:
-            Default Notion text annotations
-        """
-        return {
-            "bold": False,
-            "italic": False,
-            "strikethrough": False,
-            "underline": False,
-            "code": False,
-            "color": "default",
-        }
-
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for inline formatting.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Inline formatting can be used within most block types to style your text. You can combine multiple formatting options."
-            )
-            .with_usage_guidelines(
-                "Use inline formatting to highlight important words, provide emphasis, show code or paths, or add hyperlinks. "
-                "This helps create visual hierarchy and improves readability."
-            )
-            .with_syntax(
-                "**bold**, *italic*, `code`, ~~strikethrough~~, __underline__, [text](url)"
-            )
-            .with_examples(
-                [
-                    "This text has a **bold** word.",
-                    "This text has an *italic* word.",
-                    "This text has `code` formatting.",
-                    "This text has ~~strikethrough~~ formatting.",
-                    "This text has __underlined__ formatting.",
-                    "This has a [hyperlink](https://example.com).",
-                    "You can **combine *different* formatting** styles.",
-                ]
-            )
-            .build()
-        )

notionary/blocks/shared/text_inline_formatter_new.py

@@ -1,139 +0,0 @@
-from typing import Optional
-import re
-
-# TODO: Use this inline formatting here
-from notionary.blocks.shared.models import (
-    MentionRichText,
-    RichTextObject,
-    TextAnnotations,
-    TextContent,
-)
-
-FORMAT_PATTERNS = [
-    (r"\*\*(.+?)\*\*", {"bold": True}),
-    (r"\*(.+?)\*", {"italic": True}),
-    (r"_(.+?)_", {"italic": True}),
-    (r"__(.+?)__", {"underline": True}),
-    (r"~~(.+?)~~", {"strikethrough": True}),
-    (r"`(.+?)`", {"code": True}),
-    (r"\[(.+?)\]\((.+?)\)", {"link": True}),
-    (r"@\[([0-9a-f-]+)\]", {"mention": True}),
-]
-
-
-def parse_inline_formatting(text: str) -> list[dict[str, any]]:
-    """Parse inline text formatting into Notion rich_text format."""
-    if not text:
-        return []
-
-    return _split_text_into_segments(text)
-
-
-def _split_text_into_segments(text: str) -> list[dict[str, any]]:
-    """Split text into segments by formatting markers."""
-    segments = []
-    remaining_text = text
-
-    while remaining_text:
-        match_info = _find_earliest_match(remaining_text)
-
-        # No more formatting found - add remaining text and exit
-        if not match_info:
-            segments.append(_create_plain_text(remaining_text))
-            break
-
-        match, formatting, pos = match_info
-
-        # Add text before match if exists
-        if pos > 0:
-            segments.append(_create_plain_text(remaining_text[:pos]))
-
-        # Add formatted segment
-        segments.append(_create_formatted_segment(match, formatting))
-
-        # Update remaining text
-        remaining_text = remaining_text[pos + len(match.group(0)) :]
-
-    return segments
-
-
-def _find_earliest_match(text: str) -> Optional[tuple]:
-    """Find the earliest formatting match in text."""
-    earliest_match = None
-    earliest_format = None
-    earliest_pos = len(text)
-
-    for pattern, formatting in FORMAT_PATTERNS:
-        match = re.search(pattern, text)
-        if match and match.start() < earliest_pos:
-            earliest_match = match
-            earliest_format = formatting
-            earliest_pos = match.start()
-
-    return (earliest_match, earliest_format, earliest_pos) if earliest_match else None
-
-
-def _create_formatted_segment(match: re.Match, formatting: dict) -> dict[str, any]:
-    """Create a formatted segment based on match and formatting."""
-    if "link" in formatting:
-        return _create_link_text(match.group(1), match.group(2))
-    elif "mention" in formatting:
-        return _create_mention_text(match.group(1))
-    else:
-        return _create_formatted_text(match.group(1), **formatting)
-
-
-def _create_plain_text(content: str) -> dict[str, any]:
-    """Create plain text rich text object."""
-    return RichTextObject.from_plain_text(content).model_dump()
-
-
-def _create_formatted_text(content: str, **formatting) -> dict[str, any]:
-    """Create formatted text rich text object."""
-    return RichTextObject.from_plain_text(content, **formatting).model_dump()
-
-
-def _create_link_text(content: str, url: str) -> dict[str, any]:
-    """Create link text rich text object."""
-    text_content = TextContent(content=content, link=url)
-    annotations = TextAnnotations()
-
-    rich_text = RichTextObject(
-        text=text_content, annotations=annotations, plain_text=content, href=url
-    )
-    return rich_text.model_dump()
-
-
-def _create_mention_text(page_id: str) -> dict[str, any]:
-    """Create mention rich text object."""
-    return MentionRichText.from_page_id(page_id).model_dump()
-
-
-def extract_text_with_formatting(rich_text: list[dict[str, any]]) -> str:
-    """Convert Notion rich_text elements back to Markdown."""
-    return "".join(_rich_text_to_markdown(item) for item in rich_text)
-
-
-def _rich_text_to_markdown(text_obj: dict[str, any]) -> str:
-    """Convert single rich text object to markdown."""
-    content = text_obj.get("plain_text", text_obj.get("text", {}).get("content", ""))
-    annotations = text_obj.get("annotations", {})
-
-    # Apply formatting in reverse order
-    if annotations.get("code", False):
-        content = f"`{content}`"
-    if annotations.get("strikethrough", False):
-        content = f"~~{content}~~"
-    if annotations.get("underline", False):
-        content = f"__{content}__"
-    if annotations.get("italic", False):
-        content = f"*{content}*"
-    if annotations.get("bold", False):
-        content = f"**{content}**"
-
-    # Handle links
-    link_data = text_obj.get("text", {}).get("link")
-    if link_data and link_data.get("url"):
-        content = f"[{content}]({link_data['url']})"
-
-    return content

notionary/database/models/page_result.py

@@ -1,10 +0,0 @@
-from typing import Optional, TypedDict
-
-
-class PageResult(TypedDict, total=False):
-    """Type definition for page operation results."""
-
-    success: bool
-    page_id: str
-    url: Optional[str]
-    message: Optional[str]

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