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

notionary/blocks/rich_text/rich_text_models.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel
+from typing_extensions import Literal
+
+
+class TextAnnotations(BaseModel):
+    bold: bool = False
+    italic: bool = False
+    strikethrough: bool = False
+    underline: bool = False
+    code: bool = False
+    color: str = "default"
+
+
+class LinkObject(BaseModel):
+    url: str
+
+
+class TextContent(BaseModel):
+    content: str
+    link: Optional[LinkObject] = None
+
+
+class EquationObject(BaseModel):
+    expression: str
+
+
+class MentionUserRef(BaseModel):
+    id: str  # Notion user id
+
+
+class MentionPageRef(BaseModel):
+    id: str
+
+
+class MentionDatabaseRef(BaseModel):
+    id: str
+
+
+class MentionLinkPreview(BaseModel):
+    url: str
+
+
+class MentionDate(BaseModel):
+    # entspricht Notion date object (start Pflicht, end/time_zone optional)
+    start: str  # ISO 8601 date or datetime
+    end: Optional[str] = None
+    time_zone: Optional[str] = None
+
+
+class MentionTemplateMention(BaseModel):
+    # Notion hat zwei Template-Mention-Typen
+    type: Literal["template_mention_user", "template_mention_date"]
+
+
+class MentionObject(BaseModel):
+    type: Literal[
+        "user", "page", "database", "date", "link_preview", "template_mention"
+    ]
+    user: Optional[MentionUserRef] = None
+    page: Optional[MentionPageRef] = None
+    database: Optional[MentionDatabaseRef] = None
+    date: Optional[MentionDate] = None
+    link_preview: Optional[MentionLinkPreview] = None
+    template_mention: Optional[MentionTemplateMention] = None
+
+
+class RichTextObject(BaseModel):
+    type: Literal["text", "mention", "equation"] = "text"
+
+    text: Optional[TextContent] = None
+    annotations: Optional[TextAnnotations] = None
+    plain_text: str = ""
+    href: Optional[str] = None
+
+    mention: Optional[MentionObject] = None
+
+    equation: Optional[EquationObject] = None
+
+    @classmethod
+    def from_plain_text(cls, content: str, **ann) -> RichTextObject:
+        return cls(
+            type="text",
+            text=TextContent(content=content),
+            annotations=TextAnnotations(**ann) if ann else TextAnnotations(),
+            plain_text=content,
+        )
+
+    @classmethod
+    def for_code_block(cls, content: str) -> RichTextObject:
+        # keine annotations setzen → Notion Code-Highlight bleibt an
+        return cls(
+            type="text",
+            text=TextContent(content=content),
+            annotations=None,
+            plain_text=content,
+        )
+
+    @classmethod
+    def for_link(cls, content: str, url: str, **ann) -> RichTextObject:
+        return cls(
+            type="text",
+            text=TextContent(content=content, link=LinkObject(url=url)),
+            annotations=TextAnnotations(**ann) if ann else TextAnnotations(),
+            plain_text=content,
+        )
+
+    @classmethod
+    def mention_user(cls, user_id: str) -> RichTextObject:
+        return cls(
+            type="mention",
+            mention=MentionObject(type="user", user=MentionUserRef(id=user_id)),
+            annotations=TextAnnotations(),
+        )
+
+    @classmethod
+    def mention_page(cls, page_id: str) -> RichTextObject:
+        return cls(
+            type="mention",
+            mention=MentionObject(type="page", page=MentionPageRef(id=page_id)),
+            annotations=TextAnnotations(),
+        )
+
+    @classmethod
+    def mention_database(cls, database_id: str) -> RichTextObject:
+        return cls(
+            type="mention",
+            mention=MentionObject(
+                type="database", database=MentionDatabaseRef(id=database_id)
+            ),
+            annotations=TextAnnotations(),
+        )
+
+    @classmethod
+    def mention_link_preview(cls, url: str) -> RichTextObject:
+        return cls(
+            type="mention",
+            mention=MentionObject(
+                type="link_preview", link_preview=MentionLinkPreview(url=url)
+            ),
+            annotations=TextAnnotations(),
+        )
+
+    @classmethod
+    def mention_date(
+        cls, start: str, end: str | None = None, time_zone: str | None = None
+    ) -> RichTextObject:
+        return cls(
+            type="mention",
+            mention=MentionObject(
+                type="date", date=MentionDate(start=start, end=end, time_zone=time_zone)
+            ),
+            annotations=TextAnnotations(),
+        )
+
+    @classmethod
+    def mention_template_user(cls) -> RichTextObject:
+        return cls(
+            type="mention",
+            mention=MentionObject(
+                type="template_mention",
+                template_mention=MentionTemplateMention(type="template_mention_user"),
+            ),
+            annotations=TextAnnotations(),
+        )
+
+    @classmethod
+    def mention_template_date(cls) -> RichTextObject:
+        return cls(
+            type="mention",
+            mention=MentionObject(
+                type="template_mention",
+                template_mention=MentionTemplateMention(type="template_mention_date"),
+            ),
+            annotations=TextAnnotations(),
+        )
+
+    @classmethod
+    def equation_inline(cls, expression: str) -> RichTextObject:
+        return cls(
+            type="equation",
+            equation=EquationObject(expression=expression),
+            annotations=TextAnnotations(),
+            plain_text=expression,  # Notion liefert plain_text serverseitig; für Roundtrip hilfreich
+        )

notionary/blocks/rich_text/text_inline_formatter.py

@@ -0,0 +1,125 @@
+import re
+from typing import Any
+
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+
+
+class TextInlineFormatter:
+    FORMAT_PATTERNS: list[tuple[str, dict[str, Any]]] = [
+        (r"\*\*(.+?)\*\*", {"bold": True}),
+        (r"\*(.+?)\*", {"italic": True}),
+        (r"_(.+?)_", {"italic": True}),
+        (r"__(.+?)__", {"underline": True}),
+        (r"~~(.+?)~~", {"strikethrough": True}),
+        (r"`(.+?)`", {"code": True}),
+        (r"\[(.+?)\]\((.+?)\)", {"link": True}),
+        (r"@\[([0-9a-f-]+)\]", {"mention_page": True}),  # weiterhin deine Kurzsyntax
+    ]
+
+    @classmethod
+    def parse_inline_formatting(cls, text: str) -> list[RichTextObject]:
+        if not text:
+            return []
+        return cls._split_text_into_segments(text, cls.FORMAT_PATTERNS)
+
+    @classmethod
+    def _split_text_into_segments(
+        cls, text: str, patterns: list[tuple[str, dict[str, Any]]]
+    ) -> list[RichTextObject]:
+        segs: list[RichTextObject] = []
+        remaining = text
+
+        while remaining:
+            match, fmt, pos = None, None, len(remaining)
+            for pattern, f in patterns:
+                m = re.search(pattern, remaining)
+                if m and m.start() < pos:
+                    match, fmt, pos = m, f, m.start()
+
+            if not match:
+                segs.append(RichTextObject.from_plain_text(remaining))
+                break
+
+            if pos > 0:
+                segs.append(RichTextObject.from_plain_text(remaining[:pos]))
+
+            if "link" in fmt:
+                segs.append(RichTextObject.for_link(match.group(1), match.group(2)))
+            elif "mention_page" in fmt:
+                segs.append(RichTextObject.mention_page(match.group(1)))
+            elif "code" in fmt:
+                segs.append(RichTextObject.from_plain_text(match.group(1), code=True))
+            else:
+                segs.append(RichTextObject.from_plain_text(match.group(1), **fmt))
+
+            remaining = remaining[pos + len(match.group(0)) :]
+
+        return segs
+
+    @classmethod
+    def extract_text_with_formatting(cls, rich_text: list[RichTextObject]) -> str:
+        """
+        Convert a list of RichTextObjects back into Markdown inline syntax.
+        """
+        parts: list[str] = []
+
+        for obj in rich_text:
+            # Basisinhalt
+            content = obj.plain_text or (obj.text.content if obj.text else "")
+
+            # Equations
+            if obj.type == "equation" and obj.equation:
+                parts.append(f"${obj.equation.expression}$")
+                continue
+
+            # Mentions
+            if obj.type == "mention" and obj.mention:
+                m = obj.mention
+                if m.type == "page" and m.page:
+                    parts.append(f"@[{m.page.id}]")
+                    continue
+                elif m.type == "user" and m.user:
+                    parts.append(f"@user({m.user.id})")
+                    continue
+                elif m.type == "database" and m.database:
+                    parts.append(f"@db({m.database.id})")
+                    continue
+                elif m.type == "date" and m.date:
+                    if m.date.end:
+                        parts.append(f"{m.date.start}–{m.date.end}")
+                    else:
+                        parts.append(m.date.start)
+                    continue
+                elif m.type == "link_preview" and m.link_preview:
+                    # Als Link rendern
+                    content = f"[{content}]({m.link_preview.url})"
+                elif m.type == "template_mention" and m.template_mention:
+                    tm = m.template_mention.type
+                    parts.append(
+                        "@template_user"
+                        if tm == "template_mention_user"
+                        else "@template_date"
+                    )
+                    continue
+
+            # Normale Links (text.link)
+            if obj.text and obj.text.link:
+                url = obj.text.link.url
+                content = f"[{content}]({url})"
+
+            # Inline-Formatierungen
+            ann = obj.annotations.model_dump() if obj.annotations else {}
+            if ann.get("code"):
+                content = f"`{content}`"
+            if ann.get("strikethrough"):
+                content = f"~~{content}~~"
+            if ann.get("underline"):
+                content = f"__{content}__"
+            if ann.get("italic"):
+                content = f"*{content}*"
+            if ann.get("bold"):
+                content = f"**{content}**"
+
+            parts.append(content)
+
+        return "".join(parts)

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,69 @@
+from __future__ import annotations
+
 import re
-from typing import Dict, Any, Optional, List, Tuple
+from typing import Optional
 
-from notionary.blocks import (
-    NotionBlockElement,
-    NotionBlockResult,
-    ElementPromptContent,
-    ElementPromptBuilder,
-)
-from notionary.blocks.shared.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.models import Block, BlockCreateResult
+from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.table.table_models import CreateTableBlock, TableBlock
+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.
+    [table rows as child lines]
     """
 
+    # Pattern für Table-Zeilen (jede Zeile die mit | startet und endet)
     ROW_PATTERN = re.compile(r"^\s*\|(.+)\|\s*$")
+    # Pattern für Separator-Zeilen
     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")
-
-        if len(lines) < 2:
-            return False
-
-        # 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
-
-        return False
-
-    @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
+    def match_notion(cls, block: Block) -> bool:
         """Check if block is a Notion table."""
-        return block.get("type") == "table"
+        return block.type == BlockType.TABLE and block.table
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown table to Notion table block."""
-        if not TableElement.match_markdown(text):
-            return None
-
-        lines = text.split("\n")
-
-        table_start = TableElement._find_table_start(lines)
-        if table_start is None:
-            return None
-
-        table_end = TableElement._find_table_end(lines, table_start)
-        table_lines = lines[table_start:table_end]
-
-        rows = TableElement._extract_table_rows(table_lines)
-        if not rows:
+    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
 
-        column_count = len(rows[0])
-        TableElement._normalize_row_lengths(rows, column_count)
-
-        table_block = {
-            "type": "table",
-            "table": {
-                "table_width": column_count,
-                "has_column_header": True,
-                "has_row_header": False,
-                "children": TableElement._create_table_rows(rows),
-            },
-        }
+        # Parse the header row to determine column count
+        header_cells = cls._parse_table_row(text)
+        col_count = len(header_cells)
 
-        # Leerer Paragraph nach der Tabelle
-        empty_paragraph = {"type": "paragraph", "paragraph": {"rich_text": []}}
+        # Create empty TableBlock - content will be added by stack processor
+        table_block = TableBlock(
+            table_width=col_count,
+            has_column_header=True,
+            has_row_header=False,
+            children=[],  # Will be populated by stack processor
+        )
 
-        return [table_block, empty_paragraph]
+        return CreateTableBlock(table=table_block)
 
     @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
+    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
+
+        if not block.table:
             return None
 
-        table_data = block.get("table", {})
-        children = block.get("children", [])
+        table_data = block.table
+        children = block.children or []
 
         if not children:
-            table_width = table_data.get("table_width", 3)
-
+            table_width = table_data.table_width or 3
             header = (
                 "| " + " | ".join([f"Column {i+1}" for i in range(table_width)]) + " |"
             )
@@ -110,7 +73,6 @@ class TableElement(NotionBlockElement):
             data_row = (
                 "| " + " | ".join(["        " for _ in range(table_width)]) + " |"
             )
-
             table_rows = [header, separator, data_row]
             return "\n".join(table_rows)
 
@@ -118,11 +80,14 @@ class TableElement(NotionBlockElement):
         header_processed = False
 
         for child in children:
-            if child.get("type") != "table_row":
+            if child.type != "table_row":
+                continue
+
+            if not child.table_row:
                 continue
 
-            row_data = child.get("table_row", {})
-            cells = row_data.get("cells", [])
+            row_data = child.table_row
+            cells = row_data.cells or []
 
             row_cells = []
             for cell in cells:
@@ -132,72 +97,17 @@ class TableElement(NotionBlockElement):
             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 +119,6 @@ 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
-
-    @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 is_table_row(cls, line: str) -> bool:
+        """Check if a line is a valid table row."""
+        return bool(cls.ROW_PATTERN.match(line.strip()))