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

notionary/blocks/syntax_prompt_builder.py

@@ -0,0 +1,137 @@
+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,7 +1,21 @@
-from .table_element import TableElement
-from .table_markdown_node import TableMarkdownNode
+from notionary.blocks.table.table_element import TableElement
+from notionary.blocks.table.table_markdown_node import (
+    TableMarkdownBlockParams,
+    TableMarkdownNode,
+)
+from notionary.blocks.table.table_models import (
+    CreateTableBlock,
+    CreateTableRowBlock,
+    TableBlock,
+    TableRowBlock,
+)
 
 __all__ = [
     "TableElement",
+    "TableBlock",
+    "TableRowBlock",
+    "CreateTableRowBlock",
+    "CreateTableBlock",
     "TableMarkdownNode",
+    "TableMarkdownBlockParams",
 ]

notionary/blocks/table/table_element.py

@@ -1,106 +1,158 @@
-import re
-from typing import Dict, Any, Optional, List, Tuple
+from __future__ import annotations
 
-from notionary.blocks import (
-    NotionBlockElement,
-    NotionBlockResult,
-    ElementPromptContent,
-    ElementPromptBuilder,
+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.shared.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.types import BlockType
 
 
-class TableElement(NotionBlockElement):
+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   |
-    | Cell 4   | Cell 5   | Cell 6   |
-
-    The second line with dashes and optional colons defines column alignment.
     """
 
     ROW_PATTERN = re.compile(r"^\s*\|(.+)\|\s*$")
     SEPARATOR_PATTERN = re.compile(r"^\s*\|([\s\-:|]+)\|\s*$")
 
     @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """
-        Check if text contains a markdown table.
-        Accepts tables with only header + separator, as well as header + separator + data rows.
-        """
-        lines = text.split("\n")
+    def match_notion(cls, block: Block) -> bool:
+        """Check if block is a Notion table."""
+        return block.type == BlockType.TABLE and block.table
 
-        if len(lines) < 2:
-            return False
+    @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
 
-        # Akzeptiere Header + Separator auch ohne Datenzeile
-        for i, line in enumerate(lines[:-1]):
-            if (
-                cls.ROW_PATTERN.match(line)
-                and cls.SEPARATOR_PATTERN.match(lines[i + 1])
-            ):
-                return True
+        # Parse the header row to determine column count
+        header_cells = cls._parse_table_row(text)
+        col_count = len(header_cells)
 
-        return False
+        table_block = TableBlock(
+            table_width=col_count,
+            has_column_header=True,
+            has_row_header=False,
+            children=[],  # Will be populated by stack processor
+        )
 
-    @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
-        """Check if block is a Notion table."""
-        return block.get("type") == "table"
+        return CreateTableBlock(table=table_block)
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown table to Notion table block."""
-        if not TableElement.match_markdown(text):
+    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
 
-        lines = text.split("\n")
+        first_row = None
+        for line in table_lines:
+            line = line.strip()
+            if line and cls.ROW_PATTERN.match(line):
+                first_row = line
+                break
 
-        table_start = TableElement._find_table_start(lines)
-        if table_start is None:
+        if not first_row:
             return None
 
-        table_end = TableElement._find_table_end(lines, table_start)
-        table_lines = lines[table_start:table_end]
+        # Parse header row to determine column count
+        header_cells = cls._parse_table_row(first_row)
+        col_count = len(header_cells)
 
-        rows = TableElement._extract_table_rows(table_lines)
-        if not rows:
-            return None
+        # Process all table lines
+        table_rows, separator_found = await cls._process_table_lines(table_lines)
 
-        column_count = len(rows[0])
-        TableElement._normalize_row_lengths(rows, column_count)
+        # Create complete TableBlock
+        table_block = TableBlock(
+            table_width=col_count,
+            has_column_header=separator_found,
+            has_row_header=False,
+            children=table_rows,
+        )
 
-        table_block = {
-            "type": "table",
-            "table": {
-                "table_width": column_count,
-                "has_column_header": True,
-                "has_row_header": False,
-                "children": TableElement._create_table_rows(rows),
-            },
-        }
+        return CreateTableBlock(table=table_block)
 
-        # Leerer Paragraph nach der Tabelle
-        empty_paragraph = {"type": "paragraph", "paragraph": {"rich_text": []}}
+    @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
 
-        return [table_block, empty_paragraph]
+        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
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
         """Convert Notion table block to markdown table."""
-        if block.get("type") != "table":
+        if block.type != BlockType.TABLE:
             return None
 
-        table_data = block.get("table", {})
-        children = block.get("children", [])
+        if not block.table:
+            return None
 
-        if not children:
-            table_width = table_data.get("table_width", 3)
+        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)]) + " |"
             )
@@ -110,7 +162,6 @@ class TableElement(NotionBlockElement):
             data_row = (
                 "| " + " | ".join(["        " for _ in range(table_width)]) + " |"
             )
-
             table_rows = [header, separator, data_row]
             return "\n".join(table_rows)
 
@@ -118,86 +169,34 @@ class TableElement(NotionBlockElement):
         header_processed = False
 
         for child in children:
-            if child.get("type") != "table_row":
+            if child.type != BlockType.TABLE_ROW:
                 continue
 
-            row_data = child.get("table_row", {})
-            cells = row_data.get("cells", [])
+            if not child.table_row:
+                continue
+
+            row_data = child.table_row
+            cells = row_data.cells or []
 
             row_cells = []
             for cell in cells:
-                cell_text = TextInlineFormatter.extract_text_with_formatting(cell)
+                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.get("has_column_header", True):
+            if not header_processed and table_data.has_column_header:
                 header_processed = True
                 separator = (
                     "| " + " | ".join(["--------" for _ in range(len(cells))]) + " |"
                 )
                 table_rows.append(separator)
 
-        if not table_rows:
-            return None
-
-        if len(table_rows) == 1 and table_data.get("has_column_header", True):
-            cells_count = len(children[0].get("table_row", {}).get("cells", []))
-            separator = (
-                "| " + " | ".join(["--------" for _ in range(cells_count)]) + " |"
-            )
-            table_rows.insert(1, separator)
-
         return "\n".join(table_rows)
 
     @classmethod
-    def is_multiline(cls) -> bool:
-        """Indicates if this element handles content that spans multiple lines."""
-        return True
-
-    @classmethod
-    def _find_table_start(cls, lines: List[str]) -> Optional[int]:
-        """Find the start index of a table in the lines."""
-        for i in range(len(lines) - 2):
-            if (
-                TableElement.ROW_PATTERN.match(lines[i])
-                and TableElement.SEPARATOR_PATTERN.match(lines[i + 1])
-                and TableElement.ROW_PATTERN.match(lines[i + 2])
-            ):
-                return i
-        return None
-
-    @classmethod
-    def _find_table_end(cls, lines: List[str], start_idx: int) -> int:
-        """Find the end index of a table, starting from start_idx."""
-        end_idx = start_idx + 3  # Minimum: Header, Separator, one data row
-        while end_idx < len(lines) and TableElement.ROW_PATTERN.match(lines[end_idx]):
-            end_idx += 1
-        return end_idx
-
-    @classmethod
-    def _extract_table_rows(cls, table_lines: List[str]) -> List[List[str]]:
-        """Extract row contents from table lines, excluding separator line."""
-        rows = []
-        for i, line in enumerate(table_lines):
-            if i != 1 and TableElement.ROW_PATTERN.match(line):  # Skip separator line
-                cells = TableElement._parse_table_row(line)
-                if cells:
-                    rows.append(cells)
-        return rows
-
-    @classmethod
-    def _normalize_row_lengths(cls, rows: List[List[str]], column_count: int) -> None:
-        """Normalize row lengths to the specified column count."""
-        for row in rows:
-            if len(row) < column_count:
-                row.extend([""] * (column_count - len(row)))
-            elif len(row) > column_count:
-                del row[column_count:]
-
-    @classmethod
-    def _parse_table_row(cls, row_text: str) -> List[str]:
+    def _parse_table_row(cls, row_text: str) -> list[str]:
         """Convert table row text to cell contents."""
         row_content = row_text.strip()
 
@@ -209,109 +208,18 @@ class TableElement(NotionBlockElement):
         return [cell.strip() for cell in row_content.split("|")]
 
     @classmethod
-    def _create_table_rows(cls, rows: List[List[str]]) -> List[Dict[str, Any]]:
-        """Create Notion table rows from cell contents."""
-        table_rows = []
-
-        for row in rows:
-            cells_data = []
-
-            for cell_content in row:
-                rich_text = TextInlineFormatter.parse_inline_formatting(cell_content)
-
-                if not rich_text:
-                    rich_text = [
-                        {
-                            "type": "text",
-                            "text": {"content": ""},
-                            "annotations": {
-                                "bold": False,
-                                "italic": False,
-                                "strikethrough": False,
-                                "underline": False,
-                                "code": False,
-                                "color": "default",
-                            },
-                            "plain_text": "",
-                            "href": None,
-                        }
-                    ]
-
-                cells_data.append(rich_text)
-
-            table_rows.append({"type": "table_row", "table_row": {"cells": cells_data}})
-
-        return table_rows
-
-    @classmethod
-    def find_matches(cls, text: str) -> List[Tuple[int, int, Dict[str, Any]]]:
-        """
-        Find all tables in the text and return their positions.
-
-        Args:
-            text: The text to search in
-
-        Returns:
-            List of tuples with (start_pos, end_pos, block)
-        """
-        matches = []
-        lines = text.split("\n")
-
-        i = 0
-        while i < len(lines) - 2:
-            if (
-                TableElement.ROW_PATTERN.match(lines[i])
-                and TableElement.SEPARATOR_PATTERN.match(lines[i + 1])
-                and TableElement.ROW_PATTERN.match(lines[i + 2])
-            ):
-
-                start_line = i
-                end_line = TableElement._find_table_end(lines, start_line)
-
-                start_pos = TableElement._calculate_position(lines, 0, start_line)
-                end_pos = start_pos + TableElement._calculate_position(
-                    lines, start_line, end_line
-                )
-
-                table_text = "\n".join(lines[start_line:end_line])
-                table_block = TableElement.markdown_to_notion(table_text)
-
-                if table_block:
-                    matches.append((start_pos, end_pos, table_block))
-
-                i = end_line
-            else:
-                i += 1
-
-        return matches
-
-    @classmethod
-    def _calculate_position(cls, lines: List[str], start: int, end: int) -> int:
-        """Calculate the text position in characters from line start to end."""
-        position = 0
-        for i in range(start, end):
-            position += len(lines[i]) + 1  # +1 for newline
-        return position
+    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_llm_prompt_content(cls) -> ElementPromptContent:
-        """Returns information for LLM prompts about this element."""
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Creates formatted tables with rows and columns for structured data."
-            )
-            .with_usage_guidelines(
-                "Use tables to organize and present structured data in a grid format, making information easier to compare and analyze. Tables are ideal for data sets, comparison charts, pricing information, or any content that benefits from columnar organization."
-            )
-            .with_syntax(
-                "| Header 1 | Header 2 | Header 3 |\n| -------- | -------- | -------- |\n| Cell 1   | Cell 2   | Cell 3   |"
-            )
-            .with_examples(
-                [
-                    "| Product | Price | Stock |\n| ------- | ----- | ----- |\n| Widget A | $10.99 | 42 |\n| Widget B | $14.99 | 27 |",
-                    "| Name | Role | Department |\n| ---- | ---- | ---------- |\n| John Smith | Manager | Marketing |\n| Jane Doe | Director | Sales |",
-                ]
-            )
-            .build()
+    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,7 +1,8 @@
 from __future__ import annotations
 
 from pydantic import BaseModel
-from notionary.blocks.markdown_node import MarkdownNode
+
+from notionary.markdown.markdown_node import MarkdownNode
 
 
 class TableMarkdownBlockParams(BaseModel):

notionary/blocks/table/table_models.py

@@ -0,0 +1,28 @@
+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

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