dataops-sdk 0.3.0__py3-none-any.whl

dataops_sdk/tiptap/constants.py

@@ -0,0 +1,133 @@
+"""TipTap constants definition.
+
+Mirrors the Java TipTapConstants class with all attribute types, mark types,
+markdown syntax tokens, node types, and style constants.
+"""
+
+from enum import StrEnum
+
+
+class AttrTypes:
+    """HTML/XML attribute names."""
+
+    LEVEL = "level"
+    CHECKED = "checked"
+    SRC = "src"
+    HREF = "href"
+    ALT = "alt"
+    TITLE = "title"
+    LANGUAGE = "language"
+    COLSPAN = "colspan"
+    ROWSPAN = "rowspan"
+    ALIGNMENT = "alignment"
+    CALLOUT_TYPE = "type"
+    CALLOUT_TITLE = "title"
+    CALLOUT_COLLAPSIBLE = "collapsible"
+    CALLOUT_COLLAPSED = "collapsed"
+    COLUMNS_COUNT = "count"
+    COLUMNS_GAP = "gap"
+    COLUMN_WIDTH = "width"
+    CODE = "code"
+    ID = "id"
+    COLUMNS = "columns"
+    GAP = "gap"
+    CHART_TYPE = "chartType"
+    ITEM_TYPE = "itemType"
+
+
+class MarkTypes:
+    """Mark types for inline formatting."""
+
+    BOLD = "bold"
+    ITALIC = "italic"
+    STRIKE = "strike"
+    CODE = "code"
+    LINK = "link"
+    UNDERLINE = "underline"
+    HIGHLIGHT = "highlight"
+
+
+class Markdown:
+    """Markdown syntax tokens."""
+
+    HEADING_PREFIX = "#"
+    BLOCKQUOTE_PREFIX = "> "
+    BULLET_LIST_PREFIX = "- "
+    ORDERED_LIST_PREFIX = "%d. "
+    TASK_ITEM_UNCHECKED = "[ ]"
+    TASK_ITEM_CHECKED = "[x]"
+    HORIZONTAL_RULE = "---"
+    HARD_BREAK_SUFFIX = "\n"
+    BOLD_MARKER = "**"
+    ITALIC_MARKER = "*"
+    STRIKE_MARKER = "~~"
+    CODE_MARKER = "`"
+    HIGHLIGHT_MARKER = "=="
+    UNDERLINE_HTML_OPEN = "<u>"
+    UNDERLINE_HTML_CLOSE = "</u>"
+    CODE_BLOCK_OPEN = "```"
+    CODE_BLOCK_CLOSE = "```"
+    PARAGRAPH_SEPARATOR = "\n"
+    TABLE_ROW_SEPARATOR = " | "
+    TABLE_ALIGN_SEPARATOR = "---"
+
+
+class NodeTypes:
+    """Node type constants."""
+
+    DOC = "doc"
+    PARAGRAPH = "paragraph"
+    HEADING = "heading"
+    CODE_BLOCK = "codeBlock"
+    BLOCKQUOTE = "blockquote"
+    BULLET_LIST = "bulletList"
+    ORDERED_LIST = "orderedList"
+    TASK_LIST = "taskList"
+    TASK_ITEM = "taskItem"
+    LIST_ITEM = "listItem"
+    HORIZONTAL_RULE = "horizontalRule"
+    HARD_BREAK = "hardBreak"
+    IMAGE = "image"
+    TABLE = "table"
+    TABLE_ROW = "tableRow"
+    TABLE_CELL = "tableCell"
+    TABLE_HEADER = "tableHeader"
+    TEXT = "text"
+    FIXED_TITLE = "fixedTitle"
+    WIDGET_VIEW = "widget-view"
+    WIDGET_NUM = "widget-num"
+    AI_SKILL = "ai-skill"
+    CALLOUT = "callout"
+    COLUMNS = "columns"
+    COLUMN = "column"
+    COLUMN_RESIZER = "columnResizer"
+    MENTION = "mention"
+    TABLE_DATA = "table-data"
+    DATASET_DATA = "dataset-data"
+    MERMAID = "mermaid"
+    INSIGHT_BLOCK = "ai-insight-block"
+
+
+class IndentStyle(StrEnum):
+    """Indent style options."""
+
+    SPACE = "space"
+    TAB = "tab"
+
+
+class TableStyle(StrEnum):
+    """Table style options."""
+
+    MARKDOWN = "markdown"
+    HTML = "html"
+
+
+class Style:
+    """Style constants."""
+
+    INDENT_STYLE_SPACE = IndentStyle.SPACE
+    INDENT_STYLE_TAB = IndentStyle.TAB
+    DEFAULT_INDENT_SIZE = 2
+    TABLE_STYLE_MARKDOWN = TableStyle.MARKDOWN
+    TABLE_STYLE_HTML = TableStyle.HTML
+    DEFAULT_TABLE_STYLE = TableStyle.HTML

dataops_sdk/tiptap/markdown_parser.py

@@ -0,0 +1,294 @@
+"""Convert Markdown tokens into the JSON structure used by Tiptap."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Sequence
+from typing import Any
+
+from markdown_it import MarkdownIt
+
+from dataops_sdk.tiptap import constants, parse_utils
+
+
+class MarkdownToTipTapParser:
+    """Parse standard Markdown into frontend-compatible Tiptap JSON."""
+
+    def __init__(self) -> None:
+        self._markdown = MarkdownIt("default").enable("table")
+
+    def parse(self, markdown: str) -> dict:
+        """Parse Markdown without requiring a JavaScript runtime."""
+        tokens = self._markdown.parse(markdown)
+        content, index = self._parse_blocks(tokens)
+        if index != len(tokens):
+            raise ValueError(f"Unconsumed Markdown token at index {index}: {tokens[index].type}")
+        return parse_utils.create_doc(content)
+
+    def _parse_blocks(
+        self,
+        tokens: Sequence[Any],
+        index: int = 0,
+        closing_type: str | None = None,
+    ) -> tuple[list[dict], int]:
+        content: list[dict] = []
+
+        while index < len(tokens):
+            token = tokens[index]
+            if closing_type and token.type == closing_type:
+                return content, index + 1
+
+            if token.type == "paragraph_open":
+                node, index = self._parse_paragraph(tokens, index)
+                content.append(node)
+            elif token.type == "heading_open":
+                node, index = self._parse_heading(tokens, index)
+                content.append(node)
+            elif token.type == "blockquote_open":
+                children, index = self._parse_blocks(tokens, index + 1, "blockquote_close")
+                content.append(parse_utils.parse_blockquote(children))
+            elif token.type in {"bullet_list_open", "ordered_list_open"}:
+                node, index = self._parse_list(tokens, index)
+                content.append(node)
+            elif token.type == "fence":
+                content.append(self._parse_fence(token))
+                index += 1
+            elif token.type == "hr":
+                content.append(parse_utils.parse_horizontal_rule())
+                index += 1
+            elif token.type == "table_open":
+                node, index = self._parse_table(tokens, index)
+                content.append(node)
+            elif token.type == "html_block":
+                content.append(parse_utils.parse_paragraph([parse_utils.create_text_node(token.content)]))
+                index += 1
+            else:
+                raise ValueError(f"Unsupported Markdown block token: {token.type}")
+
+        if closing_type:
+            raise ValueError(f"Missing closing Markdown token: {closing_type}")
+        return content, index
+
+    def _parse_paragraph(
+        self,
+        tokens: Sequence[Any],
+        index: int,
+    ) -> tuple[dict, int]:
+        inline_token = self._require_token(tokens, index + 1, "inline")
+        content = self._parse_inline(inline_token.children or [])
+        close_index = index + 2
+        self._require_token(tokens, close_index, "paragraph_close")
+
+        if len(content) == 1 and content[0].get("type") == constants.NodeTypes.IMAGE:
+            return content[0], close_index + 1
+        return parse_utils.parse_paragraph(content), close_index + 1
+
+    def _parse_heading(
+        self,
+        tokens: Sequence[Any],
+        index: int,
+    ) -> tuple[dict, int]:
+        inline_token = self._require_token(tokens, index + 1, "inline")
+        content = self._parse_inline(inline_token.children or [])
+        close_index = index + 2
+        self._require_token(tokens, close_index, "heading_close")
+        level = int(tokens[index].tag[1:])
+        return parse_utils.parse_heading(content, level), close_index + 1
+
+    def _parse_list(
+        self,
+        tokens: Sequence[Any],
+        index: int,
+    ) -> tuple[dict, int]:
+        opening = tokens[index]
+        closing_type = (
+            "bullet_list_close" if opening.type == "bullet_list_open" else "ordered_list_close"
+        )
+        items: list[tuple[dict, bool]] = []
+        index += 1
+
+        while index < len(tokens) and tokens[index].type != closing_type:
+            self._require_token(tokens, index, "list_item_open")
+            item_content, index = self._parse_blocks(tokens, index + 1, "list_item_close")
+            if not item_content:
+                raise ValueError("Markdown list item has no content")
+            task_item = self._convert_task_item(item_content[0])
+            if task_item is not None:
+                task_item["content"] = item_content
+                items.append((task_item, True))
+            else:
+                items.append((parse_utils.parse_list_item(item_content), False))
+
+        self._require_token(tokens, index, closing_type)
+        index += 1
+
+        if items and all(is_task for _, is_task in items):
+            return parse_utils.parse_task_list([item for item, _ in items]), index
+
+        attrs: dict[str, int] | None = None
+        if opening.type == "ordered_list_open" and opening.attrs.get("start"):
+            attrs = {"start": opening.attrs["start"]}
+        node_type = (
+            constants.NodeTypes.BULLET_LIST
+            if opening.type == "bullet_list_open"
+            else constants.NodeTypes.ORDERED_LIST
+        )
+        return parse_utils.create_node(node_type, attrs=attrs, content=[item for item, _ in items]), index
+
+    def _convert_task_item(self, paragraph: dict) -> dict | None:
+        if paragraph.get("type") != constants.NodeTypes.PARAGRAPH:
+            return None
+        paragraph_content = paragraph.get("content") or []
+        if not paragraph_content or paragraph_content[0].get("type") != constants.NodeTypes.TEXT:
+            return None
+
+        first_text = paragraph_content[0].get("text", "")
+        match = re.match(r"^\[([ xX])\]\s+", first_text)
+        if not match:
+            return None
+
+        paragraph_content[0]["text"] = first_text[match.end() :]
+        if not paragraph_content[0]["text"]:
+            paragraph_content.pop(0)
+        checked = match.group(1).lower() == "x"
+        return parse_utils.create_node(
+            constants.NodeTypes.TASK_ITEM,
+            attrs={constants.AttrTypes.CHECKED: checked},
+        )
+
+    def _parse_fence(self, token: Any) -> dict:
+        language = token.info.strip().split(maxsplit=1)[0] if token.info.strip() else None
+        return parse_utils.parse_code_block(token.content.rstrip("\n"), language)
+
+    def _parse_table(
+        self,
+        tokens: Sequence[Any],
+        index: int,
+    ) -> tuple[dict, int]:
+        rows: list[dict] = []
+        index += 1
+        while index < len(tokens) and tokens[index].type != "table_close":
+            if tokens[index].type in {"thead_open", "tbody_open"}:
+                index += 1
+                continue
+            if tokens[index].type in {"thead_close", "tbody_close"}:
+                index += 1
+                continue
+            if tokens[index].type != "tr_open":
+                raise ValueError(f"Unexpected table token: {tokens[index].type}")
+            row, index = self._parse_table_row(tokens, index)
+            rows.append(row)
+        self._require_token(tokens, index, "table_close")
+        return parse_utils.parse_table(rows), index + 1
+
+    def _parse_table_row(
+        self,
+        tokens: Sequence[Any],
+        index: int,
+    ) -> tuple[dict, int]:
+        cells: list[dict] = []
+        index += 1
+        while index < len(tokens) and tokens[index].type != "tr_close":
+            cell_token = tokens[index]
+            if cell_token.type not in {"th_open", "td_open"}:
+                raise ValueError(f"Unexpected table cell token: {cell_token.type}")
+            inline_token = self._require_token(tokens, index + 1, "inline")
+            paragraph = parse_utils.parse_paragraph(self._parse_inline(inline_token.children or []))
+            cell_type = (
+                constants.NodeTypes.TABLE_HEADER
+                if cell_token.type == "th_open"
+                else constants.NodeTypes.TABLE_CELL
+            )
+            cells.append(parse_utils.create_node(cell_type, content=[paragraph]))
+            close_type = "th_close" if cell_token.type == "th_open" else "td_close"
+            self._require_token(tokens, index + 2, close_type)
+            index += 3
+        self._require_token(tokens, index, "tr_close")
+        return parse_utils.parse_table_row(cells), index + 1
+
+    def _parse_inline(self, tokens: Sequence[Any]) -> list[dict]:
+        result: list[dict] = []
+        marks: list[dict] = []
+        for token in tokens:
+            if token.type.endswith("_open"):
+                mark = self._mark_for_open_token(token)
+                if mark is not None:
+                    marks.append(mark)
+                continue
+            if token.type.endswith("_close"):
+                self._close_mark(marks, token)
+                continue
+            if token.type in {"text", "softbreak"}:
+                text = token.content if token.type == "text" else "\n"
+                if text:
+                    result.append(parse_utils.create_text_node(text, list(marks) or None))
+                continue
+            if token.type == "code_inline":
+                result.append(
+                    parse_utils.create_text_node(
+                        token.content,
+                        [*marks, {"type": constants.MarkTypes.CODE}],
+                    )
+                )
+                continue
+            if token.type == "hardbreak":
+                result.append(parse_utils.parse_hard_break())
+                continue
+            if token.type == "image":
+                result.append(
+                    parse_utils.create_node(
+                        constants.NodeTypes.IMAGE,
+                        attrs={
+                            constants.AttrTypes.SRC: token.attrs.get("src", ""),
+                            constants.AttrTypes.TITLE: token.attrs.get("title"),
+                            constants.AttrTypes.ALT: token.content,
+                        },
+                    )
+                )
+                continue
+            if token.type == "html_inline":
+                result.append(parse_utils.create_text_node(token.content, list(marks) or None))
+                continue
+            raise ValueError(f"Unsupported Markdown inline token: {token.type}")
+        return result
+
+    def _mark_for_open_token(self, token: Any) -> dict | None:
+        mark_types = {
+            "strong_open": constants.MarkTypes.BOLD,
+            "em_open": constants.MarkTypes.ITALIC,
+            "s_open": constants.MarkTypes.STRIKE,
+        }
+        if token.type in mark_types:
+            return {"type": mark_types[token.type]}
+        if token.type == "link_open":
+            return {
+                "type": constants.MarkTypes.LINK,
+                "attrs": {
+                    constants.AttrTypes.HREF: token.attrs.get("href", ""),
+                    constants.AttrTypes.TITLE: token.attrs.get("title"),
+                },
+            }
+        return None
+
+    def _close_mark(self, marks: list[dict], token: Any) -> None:
+        close_types = {
+            "strong_close": constants.MarkTypes.BOLD,
+            "em_close": constants.MarkTypes.ITALIC,
+            "s_close": constants.MarkTypes.STRIKE,
+            "link_close": constants.MarkTypes.LINK,
+        }
+        mark_type = close_types.get(token.type)
+        if mark_type is None:
+            return
+        for position in range(len(marks) - 1, -1, -1):
+            if marks[position]["type"] == mark_type:
+                marks.pop(position)
+                return
+        raise ValueError(f"Markdown mark closed without opening token: {token.type}")
+
+    @staticmethod
+    def _require_token(tokens: Sequence[Any], index: int, token_type: str) -> Any:
+        if index >= len(tokens) or tokens[index].type != token_type:
+            actual = tokens[index].type if index < len(tokens) else "end of input"
+            raise ValueError(f"Expected Markdown token {token_type}, got {actual}")
+        return tokens[index]

dataops_sdk/tiptap/models.py

@@ -0,0 +1,43 @@
+"""TipTap data models.
+
+Pydantic models for TipTap JSON structure.
+"""
+
+from typing import Any, Literal
+
+from pydantic import BaseModel
+
+
+class Mark(BaseModel):
+    """A mark applied to text (bold, italic, etc.)."""
+
+    type: str
+    attrs: dict[str, Any] | None = None
+
+
+class TextNode(BaseModel):
+    """Text node with optional marks."""
+
+    type: Literal["text"] = "text"
+    text: str
+    marks: list[Mark] | None = None
+
+
+class Node(BaseModel):
+    """Generic TipTap node."""
+
+    type: str
+    attrs: dict[str, Any] | None = None
+    content: list["Node"] | None = None
+    marks: list[Mark] | None = None  # For text nodes
+
+
+class DocNode(BaseModel):
+    """Document root node."""
+
+    type: Literal["doc"] = "doc"
+    content: list[Node] | None = None
+
+
+# Allow recursive model reference
+Node.model_rebuild()