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

notionary/blocks/document_element.py

@@ -1,194 +0,0 @@
-import re
-from typing import Dict, Any, Optional, List
-
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import ElementPromptContent, ElementPromptBuilder
-
-
-class DocumentElement(NotionBlockElement):
-    """
-    Handles conversion between Markdown document embeds and Notion file blocks.
-
-    Markdown document syntax (custom format):
-    - %[Caption](https://example.com/document.pdf) - Basic document with caption
-    - %[](https://example.com/document.pdf) - Document without caption
-    - %[Meeting Notes](https://drive.google.com/file/d/123/view) - Google Drive document
-    - %[Report](https://company.sharepoint.com/document.docx) - SharePoint document
-
-    Supports various document URLs including PDFs, Word docs, Excel files, PowerPoint,
-    Google Drive files, and other document formats that Notion can display.
-    """
-
-    PATTERN = re.compile(
-        r"^%\[(.*?)\]"  # %[Caption] part
-        + r'\((https?://[^\s"]+)'  # (URL part
-        + r"\)$"  # closing parenthesis
-    )
-
-    DOCUMENT_EXTENSIONS = [
-        ".pdf",
-        ".doc",
-        ".docx",
-        ".xls",
-        ".xlsx",
-        ".ppt",
-        ".pptx",
-        ".txt",
-        ".rtf",
-        ".odt",
-        ".ods",
-        ".odp",
-        ".pages",
-        ".numbers",
-        ".key",
-        ".epub",
-        ".mobi",
-    ]
-
-    @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if text is a markdown document embed."""
-        text = text.strip()
-        return text.startswith("%[") and bool(cls.PATTERN.match(text))
-
-    @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
-        """Check if block is a Notion file (document)."""
-        return block.get("type") == "file"
-
-    @classmethod
-    def is_document_url(cls, url: str) -> bool:
-        """Check if URL points to a document file."""
-        url_lower = url.lower()
-
-        # Check for common document file extensions
-        if any(url_lower.endswith(ext) for ext in cls.DOCUMENT_EXTENSIONS):
-            return True
-
-        # Check for common document hosting services
-        document_services = [
-            "drive.google.com",
-            "docs.google.com",
-            "sheets.google.com",
-            "slides.google.com",
-            "sharepoint.com",
-            "onedrive.com",
-            "dropbox.com",
-            "box.com",
-            "scribd.com",
-            "slideshare.net",
-        ]
-
-        return any(service in url_lower for service in document_services)
-
-    @classmethod
-    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
-        """Convert markdown document embed to Notion file block."""
-        doc_match = cls.PATTERN.match(text.strip())
-        if not doc_match:
-            return None
-
-        caption = doc_match.group(1)
-        url = doc_match.group(2)
-
-        if not url:
-            return None
-
-        # Verify this looks like a document URL
-        if not cls.is_document_url(url):
-            # Still proceed - user might know better than our detection
-            pass
-
-        # Prepare the file block
-        file_block = {
-            "type": "file",
-            "file": {"type": "external", "external": {"url": url}},
-        }
-
-        # Add caption if provided
-        if caption:
-            file_block["file"]["caption"] = [
-                {"type": "text", "text": {"content": caption}}
-            ]
-
-        return file_block
-
-    @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion file block to markdown document embed."""
-        if block.get("type") != "file":
-            return None
-
-        file_data = block.get("file", {})
-
-        # Handle both external and file (uploaded) documents
-        if file_data.get("type") == "external":
-            url = file_data.get("external", {}).get("url", "")
-        elif file_data.get("type") == "file":
-            url = file_data.get("file", {}).get("url", "")
-        elif file_data.get("type") == "file_upload":
-            # Handle file uploads with special notion:// syntax
-            file_upload_id = file_data.get("file_upload", {}).get("id", "")
-            if file_upload_id:
-                url = f"notion://file_upload/{file_upload_id}"
-            else:
-                return None
-        else:
-            return None
-
-        if not url:
-            return None
-
-        # Extract caption if available
-        caption = ""
-        caption_rich_text = file_data.get("caption", [])
-        if caption_rich_text:
-            caption = cls._extract_text_content(caption_rich_text)
-
-        return f"%[{caption}]({url})"
-
-    @classmethod
-    def is_multiline(cls) -> bool:
-        """Document embeds are single-line elements."""
-        return False
-
-    @classmethod
-    def _extract_text_content(cls, rich_text: List[Dict[str, Any]]) -> str:
-        """Extract plain text content from Notion rich_text elements."""
-        result = ""
-        for text_obj in rich_text:
-            if text_obj.get("type") == "text":
-                result += text_obj.get("text", {}).get("content", "")
-            elif "plain_text" in text_obj:
-                result += text_obj.get("plain_text", "")
-        return result
-
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """Returns information for LLM prompts about this element."""
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Embeds document files from external sources like PDFs, Word docs, Excel files, or cloud storage services."
-            )
-            .with_usage_guidelines(
-                "Use document embeds when you want to include reference materials, reports, presentations, or any "
-                "file-based content directly in your document. Documents can be viewed inline or downloaded by users. "
-                "Perfect for sharing contracts, reports, manuals, or any important files."
-            )
-            .with_syntax("%[Caption](https://example.com/document.pdf)")
-            .with_examples(
-                [
-                    "%[Project Proposal](https://drive.google.com/file/d/1a2b3c4d5e/view)",
-                    "%[Q4 Financial Report](https://company.sharepoint.com/reports/q4-2024.xlsx)",
-                    "%[User Manual](https://cdn.company.com/docs/manual-v2.1.pdf)",
-                    "%[Meeting Minutes](https://docs.google.com/document/d/1x2y3z4/edit)",
-                    "%[](https://example.com/contract.pdf)",
-                ]
-            )
-            .with_avoidance_guidelines(
-                "Only use for actual document files. For web pages or articles, use bookmark or embed elements instead. "
-                "Ensure document URLs are accessible to your intended audience."
-            )
-            .build()
-        )

notionary/blocks/notion_block_client.py

@@ -1,26 +0,0 @@
-from typing import Dict, Any, List
-from notionary.base_notion_client import BaseNotionClient
-from notionary.util import singleton
-
-
-# TODO: Tyoe the block api (fix registry as well)
-@singleton
-class NotionBlockClient(BaseNotionClient):
-    """
-    Client for Notion page-specific operations.
-    Inherits base HTTP functionality from BaseNotionClient.
-    """
-
-    async def get_page_blocks(self, page_id: str) -> List[Dict[str, Any]]:
-        """
-        Retrieves all blocks of a Notion page.
-        """
-        response = await self.get(f"blocks/{page_id}/children")
-        return response.get("results", [])
-
-    async def get_block_children(self, block_id: str) -> List[Dict[str, Any]]:
-        """
-        Retrieves all children blocks of a specific block.
-        """
-        response = await self.get(f"blocks/{block_id}/children")
-        return response.get("results", [])

notionary/blocks/qoute_element.py

@@ -1,169 +0,0 @@
-import re
-from typing import Dict, Any, Optional, List, Tuple
-
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import ElementPromptContent, ElementPromptBuilder
-
-
-class QuoteElement(NotionBlockElement):
-    """Class for converting between Markdown blockquotes and Notion quote blocks."""
-
-    # Regular expression pattern to match Markdown blockquote lines
-    # Matches lines that start with optional whitespace, followed by '>',
-    # then optional whitespace, and captures any text after that
-    quote_pattern = re.compile(r"^\s*>\s?(.*)", re.MULTILINE)
-
-    @classmethod
-    def find_matches(cls, text: str) -> List[Tuple[int, int, Dict[str, Any]]]:
-        """
-        Find all blockquote matches in the text and return their positions and blocks.
-        """
-        matches = []
-        quote_matches = list(QuoteElement.quote_pattern.finditer(text))
-
-        if not quote_matches:
-            return []
-
-        current_match_index = 0
-        while current_match_index < len(quote_matches):
-            start_match = quote_matches[current_match_index]
-            start_pos = start_match.start()
-
-            next_match_index = current_match_index + 1
-            while next_match_index < len(
-                quote_matches
-            ) and QuoteElement.is_consecutive_quote(
-                text, quote_matches, next_match_index
-            ):
-                next_match_index += 1
-
-            end_pos = quote_matches[next_match_index - 1].end()
-            quote_text = text[start_pos:end_pos]
-
-            block = QuoteElement.markdown_to_notion(quote_text)
-            if block:
-                matches.append((start_pos, end_pos, block))
-
-            current_match_index = next_match_index
-
-        return matches
-
-    @classmethod
-    def is_consecutive_quote(cls, text: str, quote_matches: List, index: int) -> bool:
-        """Checks if the current quote is part of the previous quote sequence."""
-        prev_end = quote_matches[index - 1].end()
-        curr_start = quote_matches[index].start()
-        gap_text = text[prev_end:curr_start]
-
-        if gap_text.count("\n") == 1:
-            return True
-
-        if gap_text.strip() == "" and gap_text.count("\n") <= 2:
-            return True
-
-        return False
-
-    @classmethod
-    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
-        """Convert markdown blockquote to Notion block."""
-        if not text:
-            return None
-
-        # Check if it's a blockquote
-        if not QuoteElement.quote_pattern.search(text):
-            return None
-
-        # Extract quote content
-        lines = text.split("\n")
-        quote_lines = []
-
-        # Extract content from each line
-        for line in lines:
-            quote_match = QuoteElement.quote_pattern.match(line)
-            if quote_match:
-                content = quote_match.group(1)
-                quote_lines.append(content)
-            elif not line.strip() and quote_lines:
-                # Allow empty lines within the quote
-                quote_lines.append("")
-
-        if not quote_lines:
-            return None
-
-        quote_content = "\n".join(quote_lines).strip()
-
-        rich_text = [{"type": "text", "text": {"content": quote_content}}]
-
-        return {"type": "quote", "quote": {"rich_text": rich_text, "color": "default"}}
-
-    @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion quote block to markdown."""
-        if block.get("type") != "quote":
-            return None
-
-        rich_text = block.get("quote", {}).get("rich_text", [])
-
-        # Extract the text content
-        content = QuoteElement._extract_text_content(rich_text)
-
-        # Format as markdown blockquote
-        lines = content.split("\n")
-        formatted_lines = []
-
-        # Add each line with blockquote prefix
-        for line in lines:
-            formatted_lines.append(f"> {line}")
-
-        return "\n".join(formatted_lines)
-
-    @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if this element can handle the given markdown text."""
-        return bool(QuoteElement.quote_pattern.search(text))
-
-    @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
-        """Check if this element can handle the given Notion block."""
-        return block.get("type") == "quote"
-
-    @classmethod
-    def is_multiline(cls) -> bool:
-        """Blockquotes can span multiple lines."""
-        return True
-
-    @classmethod
-    def _extract_text_content(cls, rich_text: List[Dict[str, Any]]) -> str:
-        """Extract plain text content from Notion rich_text elements."""
-        result = ""
-        for text_obj in rich_text:
-            if text_obj.get("type") == "text":
-                result += text_obj.get("text", {}).get("content", "")
-            elif "plain_text" in text_obj:
-                result += text_obj.get("plain_text", "")
-        return result
-
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the quote element.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Creates blockquotes that visually distinguish quoted text."
-            )
-            .with_usage_guidelines(
-                "Use blockquotes for quoting external sources, highlighting important statements, "
-                "or creating visual emphasis for key information."
-            )
-            .with_syntax("> Quoted text")
-            .with_examples(
-                [
-                    "> This is a simple blockquote",
-                    "> This is a multi-line quote\n> that continues on the next line",
-                    "> Important note:\n> This quote spans\n> multiple lines.",
-                ]
-            )
-            .build()
-        )

notionary/page/content/notion_page_content_chunker.py

@@ -1,84 +0,0 @@
-import re
-from typing import Any, Dict, List
-from notionary.util import LoggingMixin
-
-
-class NotionPageContentChunker(LoggingMixin):
-    """
-    Handles markdown text processing to comply with Notion API length limitations.
-
-    This class specifically addresses the Notion API constraint that limits
-    rich_text elements to a maximum of 2000 characters. This particularly affects
-    paragraph blocks within toggle blocks or other nested structures.
-
-    Resolves the following typical API error:
-    "validation_error - body.children[79].toggle.children[2].paragraph.rich_text[0].text.content.length
-    should be ≤ 2000, instead was 2162."
-
-    The class provides methods for:
-    1. Automatically truncating text that exceeds the limit
-    2. Splitting markdown into smaller units for separate API requests
-    """
-
-    def __init__(self, max_text_length: int = 1900):
-        self.max_text_length = max_text_length
-
-    def fix_blocks_content_length(
-        self, blocks: List[Dict[str, Any]]
-    ) -> List[Dict[str, Any]]:
-        """Check each block and ensure text content doesn't exceed Notion's limit."""
-        return [self._fix_single_block_content(block) for block in blocks]
-
-    def _fix_single_block_content(self, block: Dict[str, Any]) -> 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:
-            self._fix_rich_text_content(block_copy, block_type, content)
-
-        if "children" in content and content["children"]:
-            block_copy[block_type]["children"] = [
-                self._fix_single_block_content(child) for child in content["children"]
-            ]
-
-        return block_copy
-
-    def _fix_rich_text_content(
-        self, block_copy: Dict[str, Any], block_type: str, content: Dict[str, Any]
-    ) -> 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) <= self.max_text_length:
-                continue
-
-            self.logger.warning(
-                "Truncating text content from %d to %d chars",
-                len(text_content),
-                self.max_text_length,
-            )
-            block_copy[block_type]["rich_text"][i]["text"]["content"] = text_content[
-                : self.max_text_length
-            ]
-
-    def split_to_paragraphs(self, 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(self, paragraph: str) -> List[str]:
-        """Split a paragraph into sentences."""
-        sentences = re.split(r"(?<=[.!?])\s+", paragraph)
-        return [s for s in sentences if s.strip()]