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

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()]