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

notionary/blocks/mention/mention_element.py

@@ -1,229 +0,0 @@
-import re
-from typing import Dict, Any, Optional, List
-
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import (
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
-)
-
-
-class MentionElement(NotionBlockElement):
-    """
-    Handles conversion between Markdown mentions and Notion mention elements.
-
-    Markdown mention syntax:
-    - @[page-id] - Mention a page by its ID
-    - @date[YYYY-MM-DD] - Mention a date
-    - @db[database-id] - Mention a database by its ID
-    """
-
-    MENTION_TYPES = {
-        "page": {
-            "pattern": r"@\[([0-9a-f-]+)\]",
-            "create_mention": lambda id_value: {
-                "type": "mention",
-                "mention": {"type": "page", "page": {"id": id_value}},
-            },
-            "get_plain_text": lambda mention: f"Page {mention['mention']['page']['id']}",
-            "to_markdown": lambda mention: f"@[{mention['mention']['page']['id']}]",
-        },
-        "date": {
-            "pattern": r"@date\[(\d{4}-\d{2}-\d{2})\]",
-            "create_mention": lambda date_value: {
-                "type": "mention",
-                "mention": {"type": "date", "date": {"start": date_value, "end": None}},
-            },
-            "get_plain_text": lambda mention: mention["mention"]["date"]["start"],
-            "to_markdown": lambda mention: f"@date[{mention['mention']['date']['start']}]",
-        },
-        "database": {
-            "pattern": r"@db\[([0-9a-f-]+)\]",
-            "create_mention": lambda db_id: {
-                "type": "mention",
-                "mention": {"type": "database", "database": {"id": db_id}},
-            },
-            "get_plain_text": lambda mention: f"Database {mention['mention']['database']['id']}",
-            "to_markdown": lambda mention: f"@db[{mention['mention']['database']['id']}]",
-        },
-    }
-
-    @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if text contains a markdown mention."""
-        for mention_type in MentionElement.MENTION_TYPES.values():
-            if re.search(mention_type["pattern"], text):
-                return True
-        return False
-
-    @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
-        """Check if block contains a mention."""
-        supported_block_types = [
-            "paragraph",
-            "heading_1",
-            "heading_2",
-            "heading_3",
-            "bulleted_list_item",
-            "numbered_list_item",
-        ]
-
-        if block.get("type") not in supported_block_types:
-            return False
-
-        block_content = block.get(block.get("type"), {})
-        rich_text = block_content.get("rich_text", [])
-
-        return any(text_item.get("type") == "mention" for text_item in rich_text)
-
-    @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown text with mentions to a Notion paragraph block."""
-        if not MentionElement.match_markdown(text):
-            return None
-
-        rich_text = MentionElement._process_markdown_with_mentions(text)
-
-        return {
-            "type": "paragraph",
-            "paragraph": {"rich_text": rich_text, "color": "default"},
-        }
-
-    @classmethod
-    def _process_markdown_with_mentions(cls, text: str) -> List[Dict[str, Any]]:
-        """Convert markdown mentions to Notion rich_text format."""
-        mentions = []
-
-        for mention_type, config in MentionElement.MENTION_TYPES.items():
-            for match in re.finditer(config["pattern"], text):
-                mentions.append(
-                    {
-                        "start": match.start(),
-                        "end": match.end(),
-                        "type": mention_type,
-                        "value": match.group(1),
-                        "original": match.group(0),
-                    }
-                )
-
-        mentions.sort(key=lambda m: m["start"])
-
-        # Build rich_text list
-        rich_text = []
-        position = 0
-
-        for mention in mentions:
-            if mention["start"] > position:
-                rich_text.append(
-                    MentionElement._create_text_item(text[position : mention["start"]])
-                )
-
-            # Add the mention
-            mention_obj = MentionElement.MENTION_TYPES[mention["type"]][
-                "create_mention"
-            ](mention["value"])
-
-            # Add annotations and plain text
-            mention_obj["annotations"] = MentionElement._default_annotations()
-            mention_obj["plain_text"] = MentionElement.MENTION_TYPES[mention["type"]][
-                "get_plain_text"
-            ](mention_obj)
-
-            rich_text.append(mention_obj)
-            position = mention["end"]
-
-        # Add remaining text if any
-        if position < len(text):
-            rich_text.append(MentionElement._create_text_item(text[position:]))
-
-        return rich_text
-
-    @classmethod
-    def _create_text_item(cls, content: str) -> Dict[str, Any]:
-        """Create a text item with default annotations."""
-        text_item = {
-            "type": "text",
-            "text": {"content": content, "link": None},
-            "annotations": MentionElement._default_annotations(),
-            "plain_text": content,
-        }
-        return text_item
-
-    @classmethod
-    def _default_annotations(cls) -> Dict[str, Any]:
-        """Return default annotations for rich text."""
-        return {
-            "bold": False,
-            "italic": False,
-            "strikethrough": False,
-            "underline": False,
-            "code": False,
-            "color": "default",
-        }
-
-    @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
-        """Extract mentions from Notion block and convert to markdown format."""
-        block_type = block.get("type")
-        if not block_type or block_type not in block:
-            return None
-
-        block_content = block.get(block_type, {})
-        rich_text = block_content.get("rich_text", [])
-
-        processed_text = MentionElement._process_rich_text_with_mentions(rich_text)
-
-        if processed_text:
-            return processed_text
-
-        return None
-
-    @classmethod
-    def _process_rich_text_with_mentions(cls, rich_text: List[Dict[str, Any]]) -> str:
-        """Convert rich text with mentions to markdown string."""
-        result = []
-
-        for item in rich_text:
-            if item.get("type") == "mention":
-                mention = item.get("mention", {})
-                mention_type = mention.get("type")
-
-                if mention_type in MentionElement.MENTION_TYPES:
-                    result.append(
-                        MentionElement.MENTION_TYPES[mention_type]["to_markdown"](item)
-                    )
-                else:
-                    result.append(item.get("plain_text", "@[unknown]"))
-            else:
-                result.append(item.get("plain_text", ""))
-
-        return "".join(result)
-
-    @classmethod
-    def is_multiline(cls) -> bool:
-        return False
-
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the mention element.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "References to Notion pages, databases, or dates within text content."
-            )
-            .with_usage_guidelines(
-                "When you want to link to other Notion content within your text."
-            )
-            .with_syntax("@[page-id]")
-            .with_examples(
-                [
-                    "Check the meeting notes at @[1a6389d5-7bd3-80c5-9a87-e90b034989d0]",
-                    "Deadline is @date[2023-12-31]",
-                    "Use the structure in @db[1a6389d5-7bd3-80e9-b199-000cfb3fa0b3]",
-                ]
-            )
-            .build()
-        )

notionary/blocks/mention/mention_markdown_node.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-from typing import Literal
-from pydantic import BaseModel
-from notionary.blocks.markdown_node import MarkdownNode
-
-
-class MentionMarkdownBlockParams(BaseModel):
-    mention_type: Literal["page", "database", "date"]
-    value: str
-
-
-class MentionMarkdownNode(MarkdownNode):
-    """
-    Programmatic interface for creating Notion-style Markdown mentions.
-    Supports: page, database, date.
-    Examples: @[page-id], @db[database-id], @date[YYYY-MM-DD]
-    """
-
-    def __init__(self, mention_type: str, value: str):
-        allowed = {"page", "database", "date"}
-        if mention_type not in allowed:
-            raise ValueError(f"mention_type must be one of {allowed}")
-        self.mention_type = mention_type
-        self.value = value
-
-    @classmethod
-    def from_params(cls, params: MentionMarkdownBlockParams) -> MentionMarkdownNode:
-        return cls(mention_type=params.mention_type, value=params.value)
-
-    def to_markdown(self) -> str:
-        if self.mention_type == "page":
-            return f"@[{self.value}]"
-        elif self.mention_type == "database":
-            return f"@db[{self.value}]"
-        elif self.mention_type == "date":
-            return f"@date[{self.value}]"
-        else:
-            return f"@[{self.value}]"

notionary/blocks/prompts/element_prompt_builder.py

@@ -1,83 +0,0 @@
-from typing import Optional, List, Self
-from notionary.blocks.prompts.element_prompt_content import ElementPromptContent
-
-
-class ElementPromptBuilder:
-    """
-    Builder class for creating ElementPromptContent with a fluent interface.
-    Provides better IDE support and validation for creating prompts.
-    """
-
-    def __init__(self) -> None:
-        self._description: Optional[str] = None
-        self._syntax: Optional[str] = None
-        self._examples: List[str] = []
-        self._when_to_use: Optional[str] = None
-        self._avoid: Optional[str] = None
-        self._is_standard_markdown = False
-
-    def with_description(self, description: str) -> Self:
-        """Set the description of the element."""
-        self._description = description
-        return self
-
-    def with_syntax(self, syntax: str) -> Self:
-        """Set the syntax pattern for the element."""
-        self._syntax = syntax
-        return self
-
-    def add_example(self, example: str) -> Self:
-        """Add a usage example for the element."""
-        self._examples.append(example)
-        return self
-
-    def with_examples(self, examples: List[str]) -> Self:
-        """Set the list of usage examples for the element."""
-        self._examples = examples.copy()
-        return self
-
-    def with_usage_guidelines(self, when_to_use: str) -> Self:
-        """Set the usage guidelines for the element."""
-        self._when_to_use = when_to_use
-        return self
-
-    def with_avoidance_guidelines(self, avoid: str) -> Self:
-        """Set the scenarios when this element should be avoided."""
-        self._avoid = avoid
-        return self
-
-    def with_standard_markdown(self) -> Self:
-        """Indicate that this element follows standard Markdown syntax."""
-        self._examples = []
-        self._is_standard_markdown = True
-        return self
-
-    def build(self) -> ElementPromptContent:
-        """
-        Build and validate the ElementPromptContent object.
-
-        Returns:
-            A valid ElementPromptContent object.
-
-        Raises:
-            ValueError: If any required field is missing.
-        """
-        if not self._description:
-            raise ValueError("Description is required")
-        if not self._syntax:
-            raise ValueError("Syntax is required")
-        if not self._examples and not self._is_standard_markdown:
-            raise ValueError(
-                "At least one example is required unless it's standard markdown."
-            )
-        if not self._when_to_use:
-            raise ValueError("Usage guidelines are required")
-
-        return ElementPromptContent(
-            description=self._description,
-            syntax=self._syntax,
-            examples=self._examples,
-            when_to_use=self._when_to_use,
-            avoid=self._avoid,
-            is_standard_markdown=self._is_standard_markdown,
-        )

notionary/blocks/prompts/element_prompt_content.py

@@ -1,41 +0,0 @@
-from dataclasses import field, dataclass
-from typing import Optional, List
-
-
-@dataclass
-class ElementPromptContent:
-    """
-    Dataclass defining the standardized structure for element prompt content.
-    This ensures consistent formatting across all Notion block elements.
-    """
-
-    description: str
-    """Concise explanation of what the element is and its purpose in Notion."""
-
-    syntax: str
-    """The exact markdown syntax pattern used to create this element."""
-
-    when_to_use: str
-    """Guidelines explaining the appropriate scenarios for using this element."""
-
-    examples: List[str] = field(default_factory=list)
-    """List of practical usage examples showing the element in context."""
-
-    avoid: Optional[str] = None
-    """Optional field listing scenarios when this element should be avoided."""
-
-    is_standard_markdown: bool = False
-    """Indicates whether this element follows standard Markdown syntax (and does not require full examples)."""
-
-    def __post_init__(self):
-        """Validates that the content meets minimum requirements."""
-        if not self.description:
-            raise ValueError("Description is required")
-        if not self.syntax:
-            raise ValueError("Syntax is required")
-        if not self.examples and not self.is_standard_markdown:
-            raise ValueError(
-                "At least one example is required unless it's standard markdown."
-            )
-        if not self.when_to_use:
-            raise ValueError("Usage guidelines are required")