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

notionary/blocks/child_page/child_page_element.py

@@ -1,94 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import Optional
-
-from notionary.blocks.base_block_element import BaseBlockElement
-from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
-from notionary.blocks.models import Block, BlockCreateResult, BlockType
-from notionary.page.page_context import get_page_context
-
-
-class ChildPageElement(BaseBlockElement):
-    """
-    Handles conversion between Markdown page references and Notion child page blocks.
-
-    Creates new pages when converting from markdown.
-    """
-
-    PATTERN_BRACKET = re.compile(r"^\[page:\s*(.+)\]$", re.IGNORECASE)
-    PATTERN_EMOJI = re.compile(r"^[📝📄]\s*(.+)$")
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        return block.type == BlockType.CHILD_PAGE and getattr(block, "child_page", None)
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> Optional[BlockCreateResult]:
-        """
-        Convert markdown page syntax to an actual Notion page.
-        Returns None since child_page blocks are created implicitly via Pages API (not Blocks API).
-        """
-        context = get_page_context()
-
-        text = text.strip()
-
-        match = cls.PATTERN_BRACKET.match(text)
-        if not match:
-            match = cls.PATTERN_EMOJI.match(text)
-
-        if not match:
-            return None
-
-        title = match.group(1).strip()
-        if not title:
-            return None
-
-        # Reject multiline titles
-        if "\n" in title or "\r" in title:
-            return None
-
-        try:
-            # Create the actual page using context
-            await context.page_client.create_page(
-                title=title,
-                parent_page_id=context.page_id,
-            )
-            # Return None as per BaseBlockElement convention:
-            # child_page blocks cannot be written through the Blocks API directly.
-            # Creating a page under the parent page will automatically insert a child_page block.
-            return None
-
-        except Exception as e:
-            print(f"Failed to create page '{title}': {e}")
-            return None
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        if block.type != BlockType.CHILD_PAGE or not getattr(block, "child_page", None):
-            return None
-
-        title = block.child_page.title
-        if not title or not title.strip():
-            return None
-
-        # Use bracket syntax for output
-        return f"[page: {title.strip()}]"
-
-    @classmethod
-    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """Get system prompt information for child page blocks."""
-        return BlockElementMarkdownInformation(
-            block_type=cls.__name__,
-            description="Creates new sub-pages within a Notion page.",
-            syntax_examples=[
-                "[page: Meeting Notes]",
-                "[page: Ideas]",
-                "📝 Project Overview",
-                "📄 Research Log",
-            ],
-            usage_guidelines=(
-                "Use to create new pages that will appear as child_page blocks in the current page. "
-                "Pages are created via the Pages API with the current page as parent."
-            ),
-        )

notionary/blocks/child_page/child_page_models.py

@@ -1,12 +0,0 @@
-from typing import Literal
-
-from pydantic import BaseModel
-
-
-class ChildPageBlock(BaseModel):
-    title: str
-
-
-class CreateChildPageBlock(BaseModel):
-    type: Literal["child_page"] = "child_page"
-    child_page: ChildPageBlock

notionary/blocks/code/__init__.py

@@ -1,11 +0,0 @@
-from notionary.blocks.code.code_element import CodeElement
-from notionary.blocks.code.code_markdown_node import CodeMarkdownNode
-from notionary.blocks.code.code_models import CodeBlock, CodeLanguage, CreateCodeBlock
-
-__all__ = [
-    "CodeElement",
-    "CodeBlock",
-    "CodeLanguage",
-    "CreateCodeBlock",
-    "CodeMarkdownNode",
-]

notionary/blocks/code/code_element.py

@@ -1,149 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import Optional
-
-from notionary.blocks.base_block_element import BaseBlockElement
-from notionary.blocks.code.code_models import CodeBlock, CodeLanguage, CreateCodeBlock
-from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
-from notionary.blocks.models import Block, BlockCreateResult, BlockType
-from notionary.blocks.rich_text.rich_text_models import RichTextObject
-
-
-class CodeElement(BaseBlockElement):
-    """
-    Handles conversion between Markdown code blocks and Notion code blocks.
-    Now integrated into the LineProcessor stack system.
-
-    Markdown code block syntax:
-    ```language
-    [code content as child lines]
-    ```
-    """
-
-    DEFAULT_LANGUAGE = "plain text"
-    CODE_START_PATTERN = re.compile(r"^```(\w*)\s*$")
-    CODE_START_WITH_CAPTION_PATTERN = re.compile(r"^```(\w*)\s*(?:\"([^\"]*)\")?\s*$")
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        """Check if block is a Notion code block."""
-        return block.type == BlockType.CODE and block.code
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
-        """Convert opening ```language to Notion code block."""
-        if not (match := cls.CODE_START_PATTERN.match(text.strip())):
-            return None
-
-        language = (match.group(1) or cls.DEFAULT_LANGUAGE).lower()
-        language = cls._normalize_language(language)
-
-        # Create empty CodeBlock - content will be added by stack processor
-        code_block = CodeBlock(rich_text=[], language=language, caption=[])
-        return CreateCodeBlock(code=code_block)
-
-    @classmethod
-    def create_from_markdown_block(
-        cls, opening_line: str, code_lines: list[str]
-    ) -> BlockCreateResult:
-        """
-        Create a complete code block from markdown components.
-        """
-        match = cls.CODE_START_WITH_CAPTION_PATTERN.match(opening_line.strip())
-        if not match:
-            return None
-
-        language = (match.group(1) or cls.DEFAULT_LANGUAGE).lower()
-        language = cls._normalize_language(language)
-
-        caption = match.group(2) if match.group(2) else None
-
-        # Create rich text content from code lines
-        rich_text = []
-        if code_lines:
-            content = "\n".join(code_lines)
-            rich_text = [RichTextObject.for_code_block(content)]
-
-        caption_list = []
-        if caption:
-            caption_list = [RichTextObject.for_caption(caption)]
-
-        code_block = CodeBlock(
-            rich_text=rich_text, language=language, caption=caption_list
-        )
-
-        return CreateCodeBlock(code=code_block)
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        """Convert Notion code block to Markdown."""
-        if block.type != BlockType.CODE:
-            return None
-
-        if not block.code:
-            return None
-
-        language_enum = block.code.language
-        rich_text = block.code.rich_text or []
-        caption = block.code.caption or []
-
-        code_content = cls.extract_content(rich_text)
-        caption_text = cls.extract_caption(caption)
-
-        # Convert enum to string value
-        language = language_enum.value if language_enum else ""
-
-        # Handle language - convert "plain text" back to empty string for markdown
-        if language == cls.DEFAULT_LANGUAGE:
-            language = ""
-
-        # Build markdown code block
-        if language:
-            result = f"```{language}\n{code_content}\n```"
-        else:
-            result = f"```\n{code_content}\n```"
-
-        # Add caption if present
-        if caption_text:
-            result += f"\nCaption: {caption_text}"
-
-        return result
-
-    @classmethod
-    def _normalize_language(cls, language: str) -> CodeLanguage:
-        """
-        Normalize the language string to a valid CodeLanguage enum or default.
-        """
-        # Try to find matching enum by value
-        for lang_enum in CodeLanguage:
-            if lang_enum.value.lower() == language.lower():
-                return lang_enum
-
-        # Return default if not found
-        return CodeLanguage.PLAIN_TEXT
-
-    @staticmethod
-    def extract_content(rich_text_list: list[RichTextObject]) -> str:
-        """Extract code content from rich_text array."""
-        return "".join(rt.plain_text for rt in rich_text_list if rt.plain_text)
-
-    @staticmethod
-    def extract_caption(caption_list: list[RichTextObject]) -> str:
-        """Extract caption text from caption array."""
-        return "".join(rt.plain_text for rt in caption_list if rt.plain_text)
-
-    @classmethod
-    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """Get system prompt information for code blocks."""
-        return BlockElementMarkdownInformation(
-            block_type=cls.__name__,
-            description="Code blocks display syntax-highlighted code with optional language specification and captions",
-            syntax_examples=[
-                "```\nprint('Hello World')\n```",
-                "```python\nprint('Hello World')\n```",
-                "```python \"Example code\"\nprint('Hello World')\n```",
-                "```javascript\nconsole.log('Hello');\n```",
-            ],
-            usage_guidelines="Use for displaying code snippets. Language specification enables syntax highlighting. Caption in quotes on first line provides description. Supports many programming languages.",
-        )

notionary/blocks/code/code_markdown_node.py

@@ -1,80 +0,0 @@
-from typing import Optional
-
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-
-
-class CodeMarkdownNode(MarkdownNode):
-    """
-    Enhanced Code node with Pydantic integration.
-    Programmatic interface for creating Notion-style Markdown code blocks.
-    Automatically handles indentation normalization for multiline strings.
-
-    Example:
-        ```python "Basic usage"
-        print("Hello, world!")
-        ```
-    """
-
-    code: str
-    language: Optional[str] = None
-    caption: Optional[str] = None
-
-    def to_markdown(self) -> str:
-        lang = self.language or ""
-
-        # Build the opening fence with optional caption
-        opening_fence = f"```{lang}"
-        if self.caption:
-            opening_fence += f' "{self.caption}"'
-
-        # Smart indentation normalization
-        normalized_code = self._normalize_indentation(self.code)
-
-        content = f"{opening_fence}\n{normalized_code}\n```"
-        return content
-
-    def _normalize_indentation(self, code: str) -> str:
-        """Normalize indentation by removing common leading whitespace."""
-        lines = code.strip().split("\n")
-
-        if self._is_empty_or_single_line(lines):
-            return self._handle_simple_cases(lines)
-
-        min_indentation = self._find_minimum_indentation_excluding_first_line(lines)
-        return self._remove_common_indentation(lines, min_indentation)
-
-    def _is_empty_or_single_line(self, lines: list[str]) -> bool:
-        return not lines or len(lines) == 1
-
-    def _handle_simple_cases(self, lines: list[str]) -> str:
-        if not lines:
-            return ""
-        return lines[0].strip()
-
-    def _find_minimum_indentation_excluding_first_line(self, lines: list[str]) -> int:
-        non_empty_lines_after_first = [line for line in lines[1:] if line.strip()]
-
-        if not non_empty_lines_after_first:
-            return 0
-
-        return min(
-            len(line) - len(line.lstrip()) for line in non_empty_lines_after_first
-        )
-
-    def _remove_common_indentation(self, lines: list[str], min_indentation: int) -> str:
-        normalized_lines = [lines[0].strip()]
-
-        for line in lines[1:]:
-            normalized_line = self._normalize_single_line(line, min_indentation)
-            normalized_lines.append(normalized_line)
-
-        return "\n".join(normalized_lines)
-
-    def _normalize_single_line(self, line: str, min_indentation: int) -> str:
-        if not line.strip():
-            return ""
-
-        if len(line) > min_indentation:
-            return line[min_indentation:]
-
-        return line.strip()

notionary/blocks/code/code_models.py

@@ -1,94 +0,0 @@
-from enum import Enum
-from typing import Literal
-
-from pydantic import BaseModel, ConfigDict, Field
-
-from notionary.blocks.rich_text.rich_text_models import RichTextObject
-
-
-class CodeLanguage(str, Enum):
-    ABAP = "abap"
-    ARDUINO = "arduino"
-    BASH = "bash"
-    BASIC = "basic"
-    C = "c"
-    CLOJURE = "clojure"
-    COFFEESCRIPT = "coffeescript"
-    CPP = "c++"
-    CSHARP = "c#"
-    CSS = "css"
-    DART = "dart"
-    DIFF = "diff"
-    DOCKER = "docker"
-    ELIXIR = "elixir"
-    ELM = "elm"
-    ERLANG = "erlang"
-    FLOW = "flow"
-    FORTRAN = "fortran"
-    FSHARP = "f#"
-    GHERKIN = "gherkin"
-    GLSL = "glsl"
-    GO = "go"
-    GRAPHQL = "graphql"
-    GROOVY = "groovy"
-    HASKELL = "haskell"
-    HTML = "html"
-    JAVA = "java"
-    JAVASCRIPT = "javascript"
-    JSON = "json"
-    JULIA = "julia"
-    KOTLIN = "kotlin"
-    LATEX = "latex"
-    LESS = "less"
-    LISP = "lisp"
-    LIVESCRIPT = "livescript"
-    LUA = "lua"
-    MAKEFILE = "makefile"
-    MARKDOWN = "markdown"
-    MARKUP = "markup"
-    MATLAB = "matlab"
-    MERMAID = "mermaid"
-    NIX = "nix"
-    OBJECTIVE_C = "objective-c"
-    OCAML = "ocaml"
-    PASCAL = "pascal"
-    PERL = "perl"
-    PHP = "php"
-    PLAIN_TEXT = "plain text"
-    POWERSHELL = "powershell"
-    PROLOG = "prolog"
-    PROTOBUF = "protobuf"
-    PYTHON = "python"
-    R = "r"
-    REASON = "reason"
-    RUBY = "ruby"
-    RUST = "rust"
-    SASS = "sass"
-    SCALA = "scala"
-    SCHEME = "scheme"
-    SCSS = "scss"
-    SHELL = "shell"
-    SQL = "sql"
-    SWIFT = "swift"
-    TYPESCRIPT = "typescript"
-    VB_NET = "vb.net"
-    VERILOG = "verilog"
-    VHDL = "vhdl"
-    VISUAL_BASIC = "visual basic"
-    WEBASSEMBLY = "webassembly"
-    XML = "xml"
-    YAML = "yaml"
-    JAVA_C_CPP_CSHARP = "java/c/c++/c#"
-
-
-class CodeBlock(BaseModel):
-    caption: list[RichTextObject] = Field(default_factory=list)
-    rich_text: list[RichTextObject]
-    language: CodeLanguage = CodeLanguage.PLAIN_TEXT
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-
-class CreateCodeBlock(BaseModel):
-    type: Literal["code"] = "code"
-    code: CodeBlock

notionary/blocks/column/__init__.py

@@ -1,25 +0,0 @@
-from notionary.blocks.column.column_element import ColumnElement
-from notionary.blocks.column.column_list_element import ColumnListElement
-from notionary.blocks.column.column_list_markdown_node import (
-    ColumnListMarkdownNode,
-)
-from notionary.blocks.column.column_markdown_node import (
-    ColumnMarkdownNode,
-)
-from notionary.blocks.column.column_models import (
-    ColumnBlock,
-    ColumnListBlock,
-    CreateColumnBlock,
-    CreateColumnListBlock,
-)
-
-__all__ = [
-    "ColumnElement",
-    "ColumnListElement",
-    "ColumnBlock",
-    "CreateColumnBlock",
-    "ColumnListBlock",
-    "CreateColumnListBlock",
-    "ColumnMarkdownNode",
-    "ColumnListMarkdownNode",
-]

notionary/blocks/column/column_element.py

@@ -1,65 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import Optional
-
-from notionary.blocks.base_block_element import BaseBlockElement
-from notionary.blocks.column.column_models import ColumnBlock, CreateColumnBlock
-from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
-from notionary.blocks.models import Block, BlockCreateResult, BlockType
-
-
-class ColumnElement(BaseBlockElement):
-    """
-    Handles individual `::: column` blocks with optional width ratio.
-    Content is automatically added by the stack processor.
-
-    Supported syntax:
-    - `::: column` (equal width)
-    - `::: column 0.5` (50% width)
-    - `::: column 0.25` (25% width)
-    """
-
-    COLUMN_START = re.compile(r"^:::\s*column(?:\s+(0?\.\d+|1\.0?))?\s*$")
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        """Check if block is a Notion column."""
-        return block.type == BlockType.COLUMN and block.column
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
-        """Convert `::: column [ratio]` to Notion ColumnBlock."""
-        if not (match := cls.COLUMN_START.match(text.strip())):
-            return None
-
-        ratio_str = match.group(1)
-        width_ratio = None
-
-        if ratio_str:
-            try:
-                width_ratio = float(ratio_str)
-                # Validate ratio is between 0 and 1
-                if not (0 < width_ratio <= 1.0):
-                    width_ratio = None  # Invalid ratio, use default
-            except ValueError:
-                width_ratio = None  # Invalid format, use default
-
-        column_content = ColumnBlock(width_ratio=width_ratio)
-        return CreateColumnBlock(column=column_content)
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> str:
-        """Convert Notion column to markdown."""
-        if not cls.match_notion(block):
-            return ""
-
-        if not block.column.width_ratio:
-            return "::: column"
-
-        return f"::: column {block.column.width_ratio}"
-
-    @classmethod
-    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """Column elements are documented via ColumnListElement - return None to avoid duplication."""
-        return None

notionary/blocks/column/column_list_element.py

@@ -1,52 +0,0 @@
-from typing import Optional
-import re
-
-from notionary.blocks.base_block_element import BaseBlockElement
-from notionary.blocks.column.column_models import ColumnListBlock, CreateColumnListBlock
-from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
-from notionary.blocks.models import Block, BlockCreateResult
-from notionary.blocks.types import BlockType
-
-
-class ColumnListElement(BaseBlockElement):
-    """
-    Handles the `::: columns` container.
-    Individual columns are handled by ColumnElement.
-    """
-
-    COLUMNS_START = re.compile(r"^:::\s*columns\s*$")
-
-    @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if text starts a columns container."""
-        return bool(cls.COLUMNS_START.match(text.strip()))
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        """Check if block is a Notion column_list."""
-        return block.type == BlockType.COLUMN_LIST and block.column_list
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
-        """Convert `::: columns` to Notion ColumnListBlock."""
-        if not cls.COLUMNS_START.match(text.strip()):
-            return None
-
-        # Empty ColumnListBlock - children (columns) added by stack processor
-        column_list_content = ColumnListBlock()
-        return CreateColumnListBlock(column_list=column_list_content)
-
-    @classmethod
-    @classmethod
-    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """Get system prompt information for column list blocks."""
-        return BlockElementMarkdownInformation(
-            block_type=cls.__name__,
-            description="Column list containers organize multiple columns in side-by-side layouts",
-            syntax_examples=[
-                "::: columns\n::: column\nContent 1\n:::\n::: column\nContent 2\n:::\n:::",
-                "::: columns\n::: column 0.6\nMain content\n:::\n::: column 0.4\nSidebar\n:::\n:::",
-                "::: columns\n::: column 0.25\nLeft\n:::\n::: column 0.5\nCenter\n:::\n::: column 0.25\nRight\n:::\n:::",
-            ],
-            usage_guidelines="Use to create multi-column layouts with at least 2 columns. Column width ratios must add up to 1.0 when specified. Each column can contain any block content. Ends with :::.",
-        )

notionary/blocks/column/column_list_markdown_node.py

@@ -1,34 +0,0 @@
-from notionary.blocks.column.column_markdown_node import ColumnMarkdownNode
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-
-
-class ColumnListMarkdownNode(MarkdownNode):
-    """
-    Enhanced Column List node with Pydantic integration.
-    Programmatic interface for creating a Markdown column list container.
-    This represents the `::: columns` container that holds multiple columns.
-
-    Example:
-    ::: columns
-    ::: column
-    Left content
-    with nested lines
-    :::
-
-    ::: column 0.3
-    Right content (30% width)
-    with nested lines
-    :::
-    :::
-    """
-
-    columns: list[ColumnMarkdownNode] = []
-
-    def to_markdown(self) -> str:
-        if not self.columns:
-            return "::: columns\n:::"
-
-        column_parts = [column.to_markdown() for column in self.columns]
-        columns_content = "\n\n".join(column_parts)
-
-        return f"::: columns\n{columns_content}\n:::"

notionary/blocks/column/column_markdown_node.py

@@ -1,42 +0,0 @@
-from typing import Optional
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-
-
-class ColumnMarkdownNode(MarkdownNode):
-    """
-    Enhanced Column node with Pydantic integration.
-    Programmatic interface for creating a single Markdown column block
-    with nested content and optional width ratio.
-
-    Example:
-        ::: column
-        # Column Title
-
-        Some content here
-        :::
-
-        ::: column 0.7
-        # Wide Column (70%)
-
-        This column takes 70% width
-        :::
-    """
-
-    children: list[MarkdownNode] = []
-    width_ratio: Optional[float] = None
-
-    def to_markdown(self) -> str:
-        # Start tag with optional width ratio
-        if self.width_ratio is not None:
-            start_tag = f"::: column {self.width_ratio}"
-        else:
-            start_tag = "::: column"
-
-        if not self.children:
-            return f"{start_tag}\n:::"
-
-        # Convert children to markdown
-        content_parts = [child.to_markdown() for child in self.children]
-        content_text = "\n\n".join(content_parts)
-
-        return f"{start_tag}\n{content_text}\n:::"

notionary/blocks/column/column_models.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-from typing import Literal, Optional
-
-from pydantic import BaseModel, Field
-
-from notionary.blocks.models import BlockCreateRequest
-
-
-class ColumnBlock(BaseModel):
-    width_ratio: Optional[float] = None
-    children: list[BlockCreateRequest] = Field(default_factory=list)
-
-
-class CreateColumnBlock(BaseModel):
-    type: Literal["column"] = "column"
-    column: ColumnBlock
-
-
-class ColumnListBlock(BaseModel):
-    children: list[CreateColumnBlock] = Field(default_factory=list)
-
-
-class CreateColumnListBlock(BaseModel):
-    type: Literal["column_list"] = "column_list"
-    column_list: ColumnListBlock