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

notionary/blocks/syntax_prompt_builder.py

@@ -1,137 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from textwrap import dedent
-from typing import TYPE_CHECKING, Optional
-
-
-if TYPE_CHECKING:
-    from notionary.blocks.registry.block_registry import BlockRegistry
-
-
-@dataclass
-class BlockElementMarkdownInformation:
-    """Metadata describing how a Notion block maps to Markdown syntax."""
-
-    block_type: str
-    description: str
-    syntax_examples: list[str]
-    usage_guidelines: str
-
-
-class SyntaxPromptBuilder:
-    """
-    Builds a comprehensive markdown syntax reference from a block registry.
-    Iterates over all registered elements and collects their system prompt information.
-    """
-
-    def __init__(self, block_registry: BlockRegistry):
-        self.block_registry = block_registry
-
-    def build_markdown_reference(self) -> str:
-        """
-        Build a complete markdown syntax reference string.
-        """
-        sections = [
-            self._build_header(),
-            *self._build_element_sections(),
-        ]
-
-        return "\n\n".join(sections)
-
-    def build_concise_reference(self) -> str:
-        """
-        Build a more concise reference suitable for system prompts.
-        """
-        lines = ["# Notionary Markdown Syntax"]
-
-        for element_class in self.block_registry.get_elements():
-            info: Optional[BlockElementMarkdownInformation] = (
-                element_class.get_system_prompt_information()
-            )
-            if info and info.syntax_examples:
-                # Just show the first example for conciseness
-                example = info.syntax_examples[0]
-                lines.append(f"- {info.block_type}: `{example}`")
-
-        return "\n".join(lines)
-
-    def get_blocks_with_information(self) -> list[str]:
-        """Get list of block names that provide system prompt information."""
-        blocks = []
-
-        for element_class in self.block_registry.get_elements():
-            info: Optional[BlockElementMarkdownInformation] = (
-                element_class.get_system_prompt_information()
-            )
-            if info:
-                blocks.append(info.block_type)
-
-        return blocks
-
-    def _build_header(self) -> str:
-        """Build the header section of the reference."""
-        return dedent(
-            """
-            # Notionary Markdown Syntax Reference
-
-            This comprehensive reference documents all supported markdown syntax for converting between Markdown and Notion blocks.
-            
-            Each block type includes:
-            - **Description:** What the block does
-            - **When to use:** Guidelines for appropriate usage
-            - **Syntax:** Complete syntax examples with variations
-        """
-        ).strip()
-
-    def _build_element_sections(self) -> list[str]:
-        """Build sections for all registered elements."""
-        sections = []
-
-        for element_class in self.block_registry.get_elements():
-            info = element_class.get_system_prompt_information()
-            if info:
-                sections.append(self._build_element_section(info))
-
-        return sections
-
-    def _build_element_section(self, info: BlockElementMarkdownInformation) -> str:
-        """Build a well-structured section for a single block element."""
-        section_parts = [
-            f"## {info.block_type}",
-            "",
-            f"**Description:** {info.description}",
-            "",
-        ]
-
-        if info.usage_guidelines:
-            section_parts.extend(["**When to use:**", info.usage_guidelines, ""])
-
-        if info.syntax_examples:
-            section_parts.extend(
-                [
-                    "**Syntax:**",
-                    "",
-                    *self._format_syntax_examples(info.syntax_examples),
-                    "",
-                ]
-            )
-
-        return "\n".join(section_parts).rstrip()
-
-    def _format_syntax_examples(self, examples: list[str]) -> list[str]:
-        """Format syntax examples with proper markdown and clear structure."""
-        formatted = []
-
-        for i, example in enumerate(examples, 1):
-            if len(examples) > 1:
-                formatted.append(f"**Example {i}:**")
-
-            if "\n" in example:
-                # Multi-line example - use code block
-                formatted.extend(["```", example, "```", ""])
-            else:
-                # Single line - use inline code with description
-                formatted.extend([f"`{example}`", ""])
-
-        return formatted

notionary/blocks/table/__init__.py

@@ -1,19 +0,0 @@
-from notionary.blocks.table.table_element import TableElement
-from notionary.blocks.table.table_markdown_node import (
-    TableMarkdownNode,
-)
-from notionary.blocks.table.table_models import (
-    CreateTableBlock,
-    CreateTableRowBlock,
-    TableBlock,
-    TableRowBlock,
-)
-
-__all__ = [
-    "TableElement",
-    "TableBlock",
-    "TableRowBlock",
-    "CreateTableRowBlock",
-    "CreateTableBlock",
-    "TableMarkdownNode",
-]

notionary/blocks/table/table_element.py

@@ -1,225 +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
-from notionary.blocks.rich_text.rich_text_models import RichTextObject
-from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
-from notionary.blocks.table.table_models import (
-    CreateTableBlock,
-    TableBlock,
-    CreateTableRowBlock,
-    TableRowBlock,
-)
-from notionary.blocks.types import BlockType
-
-
-class TableElement(BaseBlockElement):
-    """
-    Handles conversion between Markdown tables and Notion table blocks.
-    Now integrated into the LineProcessor stack system.
-
-    Markdown table syntax:
-    | Header 1 | Header 2 | Header 3 |
-    | -------- | -------- | -------- |
-    | Cell 1   | Cell 2   | Cell 3   |
-    """
-
-    ROW_PATTERN = re.compile(r"^\s*\|(.+)\|\s*$")
-    SEPARATOR_PATTERN = re.compile(r"^\s*\|([\s\-:|]+)\|\s*$")
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        """Check if block is a Notion table."""
-        return block.type == BlockType.TABLE and block.table
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
-        """Convert opening table row to Notion table block."""
-        if not cls.ROW_PATTERN.match(text.strip()):
-            return None
-
-        # Parse the header row to determine column count
-        header_cells = cls._parse_table_row(text)
-        col_count = len(header_cells)
-
-        table_block = TableBlock(
-            table_width=col_count,
-            has_column_header=True,
-            has_row_header=False,
-            children=[],  # Will be populated by stack processor
-        )
-
-        return CreateTableBlock(table=table_block)
-
-    @classmethod
-    async def create_from_markdown_table(
-        cls, table_lines: list[str]
-    ) -> BlockCreateResult:
-        """
-        Create a complete table block from markdown table lines.
-        """
-        if not table_lines:
-            return None
-
-        first_row = None
-        for line in table_lines:
-            line = line.strip()
-            if line and cls.ROW_PATTERN.match(line):
-                first_row = line
-                break
-
-        if not first_row:
-            return None
-
-        # Parse header row to determine column count
-        header_cells = cls._parse_table_row(first_row)
-        col_count = len(header_cells)
-
-        # Process all table lines
-        table_rows, separator_found = await cls._process_table_lines(table_lines)
-
-        # Create complete TableBlock
-        table_block = TableBlock(
-            table_width=col_count,
-            has_column_header=separator_found,
-            has_row_header=False,
-            children=table_rows,
-        )
-
-        return CreateTableBlock(table=table_block)
-
-    @classmethod
-    async def _process_table_lines(
-        cls, table_lines: list[str]
-    ) -> tuple[list[CreateTableRowBlock], bool]:
-        """Process all table lines and return rows and separator status."""
-        table_rows = []
-        separator_found = False
-
-        for line in table_lines:
-            line = line.strip()
-            if not line:
-                continue
-
-            if cls._is_separator_line(line):
-                separator_found = True
-                continue
-
-            if cls.ROW_PATTERN.match(line):
-                table_row = await cls._create_table_row_from_line(line)
-                table_rows.append(table_row)
-
-        return table_rows, separator_found
-
-    @classmethod
-    def _is_separator_line(cls, line: str) -> bool:
-        """Check if line is a table separator (|---|---|)."""
-        return cls.SEPARATOR_PATTERN.match(line) is not None
-
-    @classmethod
-    async def _create_table_row_from_line(cls, line: str) -> CreateTableRowBlock:
-        """Create a table row block from a markdown line."""
-        cells = cls._parse_table_row(line)
-        rich_text_cells = []
-        for cell in cells:
-            rich_text_cell = await cls._convert_cell_to_rich_text(cell)
-            rich_text_cells.append(rich_text_cell)
-        table_row = TableRowBlock(cells=rich_text_cells)
-        return CreateTableRowBlock(table_row=table_row)
-
-    @classmethod
-    async def _convert_cell_to_rich_text(cls, cell: str) -> list[RichTextObject]:
-        """Convert cell text to rich text objects."""
-        rich_text = await TextInlineFormatter.parse_inline_formatting(cell)
-        if not rich_text:
-            rich_text = [RichTextObject.from_plain_text(cell)]
-        return rich_text
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        """Convert Notion table block to markdown table."""
-        if block.type != BlockType.TABLE:
-            return None
-
-        if not block.table:
-            return None
-
-        table_data = block.table
-        children = block.children or []
-
-        if not children:
-            table_width = table_data.table_width or 3
-            header = (
-                "| " + " | ".join([f"Column {i+1}" for i in range(table_width)]) + " |"
-            )
-            separator = (
-                "| " + " | ".join(["--------" for _ in range(table_width)]) + " |"
-            )
-            data_row = (
-                "| " + " | ".join(["        " for _ in range(table_width)]) + " |"
-            )
-            table_rows = [header, separator, data_row]
-            return "\n".join(table_rows)
-
-        table_rows = []
-        header_processed = False
-
-        for child in children:
-            if child.type != BlockType.TABLE_ROW:
-                continue
-
-            if not child.table_row:
-                continue
-
-            row_data = child.table_row
-            cells = row_data.cells or []
-
-            row_cells = []
-            for cell in cells:
-                cell_text = await TextInlineFormatter.extract_text_with_formatting(cell)
-                row_cells.append(cell_text or "")
-
-            row = "| " + " | ".join(row_cells) + " |"
-            table_rows.append(row)
-
-            if not header_processed and table_data.has_column_header:
-                header_processed = True
-                separator = (
-                    "| " + " | ".join(["--------" for _ in range(len(cells))]) + " |"
-                )
-                table_rows.append(separator)
-
-        return "\n".join(table_rows)
-
-    @classmethod
-    def _parse_table_row(cls, row_text: str) -> list[str]:
-        """Convert table row text to cell contents."""
-        row_content = row_text.strip()
-
-        if row_content.startswith("|"):
-            row_content = row_content[1:]
-        if row_content.endswith("|"):
-            row_content = row_content[:-1]
-
-        return [cell.strip() for cell in row_content.split("|")]
-
-    @classmethod
-    def is_table_row(cls, line: str) -> bool:
-        """Check if a line is a valid table row."""
-        return bool(cls.ROW_PATTERN.match(line.strip()))
-
-    @classmethod
-    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """Get system prompt information for table blocks."""
-        return BlockElementMarkdownInformation(
-            block_type=cls.__name__,
-            description="Table blocks create structured data in rows and columns with headers",
-            syntax_examples=[
-                "| Name | Age | City |\n| -------- | -------- | -------- |\n| Alice | 25 | Berlin |\n| Bob | 30 | Munich |"
-            ],
-            usage_guidelines="Use for structured data presentation. First row is header, second row is separator with dashes, following rows are data. Cells are separated by | characters.",
-        )

notionary/blocks/table/table_markdown_node.py

@@ -1,42 +0,0 @@
-from pydantic import field_validator
-
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-
-
-class TableMarkdownNode(MarkdownNode):
-    """
-    Enhanced Table node with Pydantic integration.
-    Programmatic interface for creating Markdown tables.
-    Example:
-        | Header 1 | Header 2 | Header 3 |
-        | -------- | -------- | -------- |
-        | Cell 1   | Cell 2   | Cell 3   |
-        | Cell 4   | Cell 5   | Cell 6   |
-    """
-
-    headers: list[str]
-    rows: list[list[str]]
-
-    @field_validator("headers")
-    @classmethod
-    def validate_headers(cls, v):
-        if not v:
-            raise ValueError("headers must not be empty")
-        return v
-
-    @field_validator("rows")
-    @classmethod
-    def validate_rows(cls, v):
-        if not all(isinstance(row, list) for row in v):
-            raise ValueError("rows must be a list of lists")
-        return v
-
-    def to_markdown(self) -> str:
-        col_count = len(self.headers)
-        # Header row
-        header = "| " + " | ".join(self.headers) + " |"
-        # Separator row
-        separator = "| " + " | ".join(["--------"] * col_count) + " |"
-        # Data rows
-        data_rows = ["| " + " | ".join(row) + " |" for row in self.rows]
-        return "\n".join([header, separator] + data_rows)

notionary/blocks/table/table_models.py

@@ -1,28 +0,0 @@
-from __future__ import annotations
-
-from typing import Literal
-
-from pydantic import BaseModel
-
-from notionary.blocks.rich_text.rich_text_models import RichTextObject
-
-
-class TableBlock(BaseModel):
-    table_width: int
-    has_column_header: bool = False
-    has_row_header: bool = False
-    children: list[CreateTableRowBlock] = []
-
-
-class TableRowBlock(BaseModel):
-    cells: list[list[RichTextObject]]
-
-
-class CreateTableRowBlock(BaseModel):
-    type: Literal["table_row"] = "table_row"
-    table_row: TableRowBlock
-
-
-class CreateTableBlock(BaseModel):
-    type: Literal["table"] = "table"
-    table: TableBlock

notionary/blocks/table_of_contents/__init__.py

@@ -1,17 +0,0 @@
-from notionary.blocks.table_of_contents.table_of_contents_element import (
-    TableOfContentsElement,
-)
-from notionary.blocks.table_of_contents.table_of_contents_markdown_node import (
-    TableOfContentsMarkdownNode,
-)
-from notionary.blocks.table_of_contents.table_of_contents_models import (
-    CreateTableOfContentsBlock,
-    TableOfContentsBlock,
-)
-
-__all__ = [
-    "TableOfContentsElement",
-    "TableOfContentsBlock",
-    "CreateTableOfContentsBlock",
-    "TableOfContentsMarkdownNode",
-]

notionary/blocks/table_of_contents/table_of_contents_element.py

@@ -1,80 +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
-from notionary.blocks.table_of_contents.table_of_contents_models import (
-    CreateTableOfContentsBlock,
-    TableOfContentsBlock,
-)
-from notionary.blocks.types import BlockType, BlockColor
-
-
-class TableOfContentsElement(BaseBlockElement):
-    """
-    Handles conversion between Markdown [toc] syntax and Notion table_of_contents blocks.
-
-    Markdown syntax:
-    - [toc]                        → default color (enum default)
-    - [toc](blue)                  → custom color
-    - [toc](blue_background)       → custom background color
-    """
-
-    PATTERN = re.compile(r"^\[toc\](?:\((?P<color>[a-z_]+)\))?$", re.IGNORECASE)
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        return block.type == BlockType.TABLE_OF_CONTENTS and block.table_of_contents
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
-        if not (input_match := cls.PATTERN.match(text.strip())):
-            return None
-
-        color_str = input_match.group("color")
-        if color_str:
-            # Validate against the enum; fallback to default if unknown
-            try:
-                color = BlockColor(color_str.lower())
-                toc_payload = TableOfContentsBlock(color=color)
-            except ValueError:
-                # Unknown color → omit to use enum default
-                toc_payload = TableOfContentsBlock()
-        else:
-            # No color provided → omit to let enum default apply
-            toc_payload = TableOfContentsBlock()
-
-        return CreateTableOfContentsBlock(table_of_contents=toc_payload)
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        # Correct guard: if not a TOC or missing payload → no match
-        if block.type != BlockType.TABLE_OF_CONTENTS or not block.table_of_contents:
-            return None
-
-        color = block.table_of_contents.color
-        # If None or default → plain [toc]
-        if color is None or color == BlockColor.DEFAULT:
-            return "[toc]"
-        return f"[toc]({color.value})"
-
-    @classmethod
-    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """System prompt info for table of contents blocks."""
-        return BlockElementMarkdownInformation(
-            block_type=cls.__name__,
-            description="Table of contents blocks automatically generate navigation for page headings.",
-            syntax_examples=[
-                "[toc]",
-                "[toc](blue)",
-                "[toc](blue_background)",
-                "[toc](gray_background)",
-            ],
-            usage_guidelines=(
-                "Use to auto-generate a clickable table of contents from page headings. "
-                "The color parameter is optional; if omitted, the default enum color is used."
-            ),
-        )

notionary/blocks/table_of_contents/table_of_contents_markdown_node.py

@@ -1,21 +0,0 @@
-from typing import Optional
-
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-
-
-class TableOfContentsMarkdownNode(MarkdownNode):
-    """
-    Enhanced Table of Contents node with Pydantic integration.
-    Programmatic interface for creating Markdown table of contents blocks.
-    Example:
-    [toc]
-    [toc](blue)
-    [toc](blue_background)
-    """
-
-    color: Optional[str] = "default"
-
-    def to_markdown(self) -> str:
-        if self.color == "default":
-            return "[toc]"
-        return f"[toc]({self.color})"

notionary/blocks/table_of_contents/table_of_contents_models.py

@@ -1,18 +0,0 @@
-from typing import Literal, Optional
-
-from pydantic import BaseModel
-
-from notionary.blocks.types import BlockColor
-
-
-class TableOfContentsBlock(BaseModel):
-    """Inneres Payload-Objekt: { table_of_contents: { color: ... } }"""
-
-    color: Optional[BlockColor] = BlockColor.DEFAULT
-
-
-class CreateTableOfContentsBlock(BaseModel):
-    """Create-Payload für den Block: { type: 'table_of_contents', table_of_contents: {...} }"""
-
-    type: Literal["table_of_contents"] = "table_of_contents"
-    table_of_contents: TableOfContentsBlock

notionary/blocks/todo/__init__.py

@@ -1,12 +0,0 @@
-from notionary.blocks.todo.todo_element import TodoElement
-from notionary.blocks.todo.todo_markdown_node import (
-    TodoMarkdownNode,
-)
-from notionary.blocks.todo.todo_models import CreateToDoBlock, ToDoBlock
-
-__all__ = [
-    "TodoElement",
-    "ToDoBlock",
-    "CreateToDoBlock",
-    "TodoMarkdownNode",
-]

notionary/blocks/todo/todo_element.py

@@ -1,81 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import TYPE_CHECKING, 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.blocks.rich_text.text_inline_formatter import TextInlineFormatter
-from notionary.blocks.todo.todo_models import CreateToDoBlock, ToDoBlock
-
-
-class TodoElement(BaseBlockElement):
-    """
-    Handles conversion between Markdown todo items and Notion to_do blocks.
-
-    Markdown syntax examples:
-    - [ ] Unchecked todo item
-    - [x] Checked todo item
-    * [ ] Also works with asterisk
-    + [ ] Also works with plus sign
-    """
-
-    PATTERN = re.compile(r"^\s*[-*+]\s+\[ \]\s+(.+)$")
-    DONE_PATTERN = re.compile(r"^\s*[-*+]\s+\[x\]\s+(.+)$", re.IGNORECASE)
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        return block.type == BlockType.TO_DO and block.to_do
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
-        """Convert markdown todo or done item to Notion to_do block."""
-        m_done = cls.DONE_PATTERN.match(text)
-        m_todo = None if m_done else cls.PATTERN.match(text)
-
-        if m_done:
-            content = m_done.group(1)
-            checked = True
-        elif m_todo:
-            content = m_todo.group(1)
-            checked = False
-        else:
-            return None
-
-        # build rich text
-        rich = await TextInlineFormatter.parse_inline_formatting(content)
-
-        todo_content = ToDoBlock(
-            rich_text=rich,
-            checked=checked,
-            color="default",
-        )
-        return CreateToDoBlock(to_do=todo_content)
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        """Convert Notion to_do block to markdown todo item."""
-        if block.type != BlockType.TO_DO or not block.to_do:
-            return None
-
-        td = block.to_do
-        content = await TextInlineFormatter.extract_text_with_formatting(td.rich_text)
-        checkbox = "[x]" if td.checked else "[ ]"
-        return f"- {checkbox} {content}"
-
-    @classmethod
-    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """Get system prompt information for todo blocks."""
-        return BlockElementMarkdownInformation(
-            block_type=cls.__name__,
-            description="Todo blocks create interactive checkboxes for task management",
-            syntax_examples=[
-                "- [ ] Unchecked todo item",
-                "- [x] Checked todo item",
-                "* [ ] Todo with asterisk",
-                "+ [ ] Todo with plus sign",
-                "- [x] Completed task",
-            ],
-            usage_guidelines="Use for task lists and checkboxes. [ ] for unchecked, [x] for checked items. Supports -, *, or + as bullet markers. Interactive in Notion interface.",
-        )