dataops-sdk 0.3.0__py3-none-any.whl

dataops_sdk/tiptap/render_utils.py

@@ -0,0 +1,846 @@
+"""TipTap rendering utilities.
+
+Provides functions to render TipTap JSON to Markdown format.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from dataops_sdk.tiptap import constants
+
+if TYPE_CHECKING:
+    from dataops_sdk.tiptap.tool import TipTapTool
+
+
+def render_paragraph(node: dict, content: str, parent_type: str | None) -> str:
+    """Render a paragraph node.
+
+    Args:
+        node: Paragraph node
+        content: Rendered child content
+        parent_type: Parent node type
+
+    Returns:
+        Markdown formatted paragraph
+    """
+    if content is None:
+        content = ""
+    return content + constants.Markdown.PARAGRAPH_SEPARATOR
+
+
+def render_heading(node: dict, level: int, content: str) -> str:
+    """Render a heading node.
+
+    Args:
+        node: Heading node
+        level: Heading level
+        content: Rendered child content
+
+    Returns:
+        Markdown formatted heading
+    """
+    if content is None:
+        content = ""
+    return f"{constants.Markdown.HEADING_PREFIX * level} {content}{constants.Markdown.PARAGRAPH_SEPARATOR}"
+
+
+def render_code_block(node: dict, content: str) -> str:
+    """Render a code block node.
+
+    Args:
+        node: Code block node
+        content: Rendered child content
+
+    Returns:
+        Markdown formatted code block
+    """
+    language = ""
+    attrs = node.get("attrs")
+    if attrs:
+        language = attrs.get(constants.AttrTypes.LANGUAGE, "")
+    if content is None:
+        content = ""
+    return (
+        f"{constants.Markdown.CODE_BLOCK_OPEN}{language}\n"
+        f"{content}\n"
+        f"{constants.Markdown.CODE_BLOCK_CLOSE}"
+        f"{constants.Markdown.PARAGRAPH_SEPARATOR}"
+    )
+
+
+def render_blockquote(content: str) -> str:
+    """Render a blockquote node.
+
+    Args:
+        content: Rendered child content
+
+    Returns:
+        Markdown formatted blockquote
+    """
+    if not content or not content.strip():
+        return ""
+
+    lines = content.strip().split("\n")
+    result = []
+    for line in lines:
+        if not line:
+            result.append(f"{constants.Markdown.BLOCKQUOTE_PREFIX}\n")
+        else:
+            result.append(f"{constants.Markdown.BLOCKQUOTE_PREFIX}{line}\n")
+    return "".join(result) + constants.Markdown.PARAGRAPH_SEPARATOR
+
+
+def render_bullet_list(content: str) -> str:
+    """Render a bullet list node.
+
+    Args:
+        content: Rendered child content
+
+    Returns:
+        Markdown formatted bullet list
+    """
+    if not content:
+        return ""
+    return content
+
+
+def render_ordered_list(content: str) -> str:
+    """Render an ordered list node.
+
+    Args:
+        content: Rendered child content
+
+    Returns:
+        Markdown formatted ordered list
+    """
+    if not content:
+        return ""
+    return content
+
+
+def render_list_item(
+    node: dict,
+    content: str,
+    parent_type: str | None,
+    index: int,
+) -> str:
+    """Render a list item node.
+
+    Args:
+        node: List item node
+        content: Rendered child content
+        parent_type: Parent node type
+        index: Index of this item
+
+    Returns:
+        Markdown formatted list item
+    """
+    if content is None:
+        return ""
+
+    if parent_type == constants.NodeTypes.ORDERED_LIST:
+        prefix = f"{index + 1}. "
+    else:
+        prefix = constants.Markdown.BULLET_LIST_PREFIX
+
+    lines = content.split("\n")
+    if len(lines) == 1:
+        return f"{prefix}{lines[0]}\n"
+
+    result = [f"{prefix}{lines[0]}\n"]
+    indent = " " * len(prefix)
+    for line in lines[1:]:
+        result.append(f"{indent}{line}\n")
+    return "".join(result)
+
+
+def render_horizontal_rule() -> str:
+    """Render a horizontal rule node.
+
+    Returns:
+        Markdown formatted horizontal rule
+    """
+    return constants.Markdown.HORIZONTAL_RULE + constants.Markdown.PARAGRAPH_SEPARATOR
+
+
+def render_hard_break() -> str:
+    """Render a hard break node.
+
+    Returns:
+        Markdown formatted hard break
+    """
+    return constants.Markdown.HARD_BREAK_SUFFIX
+
+
+def render_image(node: dict) -> str:
+    """Render an image node.
+
+    Args:
+        node: Image node
+
+    Returns:
+        Markdown formatted image
+    """
+    attrs = node.get("attrs")
+    src = attrs.get(constants.AttrTypes.SRC, "") if attrs else ""
+    alt = attrs.get(constants.AttrTypes.ALT, "") if attrs else ""
+    title = attrs.get(constants.AttrTypes.TITLE, "") if attrs else ""
+
+    if alt:
+        if title:
+            image_markdown = f'![{alt}]({src} "{title}")'
+        else:
+            image_markdown = f"![{alt}]({src})"
+    else:
+        if title:
+            image_markdown = f'![]({src} "{title}")'
+        else:
+            image_markdown = f"![]({src})"
+
+    return image_markdown + constants.Markdown.PARAGRAPH_SEPARATOR
+
+
+def render_table_to_md_format(node: dict) -> str:
+    """Render a table node to Markdown format.
+
+    Args:
+        node: Table node
+
+    Returns:
+        Markdown formatted table
+    """
+    content = node.get("content")
+    if not content:
+        return ""
+
+    rows_data: list[list[tuple[str, bool]]] = []
+
+    for row_node in content:
+        cells = row_node.get("content")
+        if not cells:
+            continue
+
+        row: list[tuple[str, bool]] = []
+        for cell_node in cells:
+            cell_text = _extract_cell_text(cell_node)
+            is_header = cell_node.get("type") == constants.NodeTypes.TABLE_HEADER
+            row.append((cell_text, is_header))
+        rows_data.append(row)
+
+    if not rows_data:
+        return ""
+
+    column_count = max(len(row) for row in rows_data)
+    if column_count == 0:
+        return ""
+
+    col_widths = [3] * column_count
+    for row in rows_data:
+        for i, (cell_text, _) in enumerate(row):
+            if len(cell_text) > col_widths[i]:
+                col_widths[i] = len(cell_text)
+
+    header_row = rows_data[0]
+    has_header = any(is_header for _, is_header in header_row)
+
+    out_lines: list[str] = []
+
+    header_texts = []
+    for i in range(column_count):
+        if has_header and i < len(header_row):
+            header_texts.append(header_row[i][0])
+        else:
+            header_texts.append("")
+
+    out_lines.append(
+        "| " + " | ".join(_pad_text(t, w) for t, w in zip(header_texts, col_widths)) + " |"
+    )
+    out_lines.append("| " + " | ".join("-" * max(3, w) for w in col_widths) + " |")
+
+    start_row = 1 if has_header else 0
+    for r in range(start_row, len(rows_data)):
+        row = rows_data[r]
+        cell_texts = []
+        for i in range(column_count):
+            if i < len(row):
+                cell_texts.append(row[i][0])
+            else:
+                cell_texts.append("")
+        out_lines.append(
+            "| " + " | ".join(_pad_text(t, w) for t, w in zip(cell_texts, col_widths)) + " |"
+        )
+
+    return "".join(line + "\n" for line in out_lines) + "\n"
+
+
+def render_table_to_html_format(tool: "TipTapTool", node: dict) -> str:
+    """Render a table node to HTML format.
+
+    Args:
+        tool: TipTapTool instance
+        node: Table node
+
+    Returns:
+        HTML formatted table
+    """
+    content = node.get("content")
+    if not content:
+        return ""
+
+    rows_data: list[list[dict[str, Any]]] = []
+
+    for row_node in content:
+        cells = row_node.get("content")
+        if not cells:
+            continue
+
+        row: list[dict[str, Any]] = []
+        for cell_node in cells:
+            cell_text = _extract_cell_content(tool, cell_node)
+            is_header = cell_node.get("type") == constants.NodeTypes.TABLE_HEADER
+
+            attrs = cell_node.get("attrs") or {}
+            colspan = attrs.get(constants.AttrTypes.COLSPAN, 1)
+            rowspan = attrs.get(constants.AttrTypes.ROWSPAN, 1)
+            alignment = attrs.get(constants.AttrTypes.ALIGNMENT, "")
+
+            html_attrs = ""
+            if colspan > 1:
+                html_attrs += f' colspan="{colspan}"'
+            if rowspan > 1:
+                html_attrs += f' rowspan="{rowspan}"'
+            if alignment:
+                html_attrs += f' style="text-align: {alignment};"'
+
+            row.append({"text": cell_text, "is_header": is_header, "attrs": html_attrs})
+        rows_data.append(row)
+
+    if not rows_data:
+        return ""
+
+    out = "<table>\n"
+
+    has_header_row = rows_data[0] and any(cell["is_header"] for cell in rows_data[0])
+
+    if has_header_row:
+        out += "<thead><tr>"
+        for cell in rows_data[0]:
+            tag = "th" if cell["is_header"] else "td"
+            attrs = f" {cell['attrs']}" if cell["attrs"] else ""
+            out += f"<{tag}{attrs}>{cell['text']}</{tag}>"
+        out += "</tr></thead>\n"
+        body_rows = rows_data[1:]
+    else:
+        body_rows = rows_data
+
+    out += "<tbody>\n"
+    for row in body_rows:
+        out += "<tr>"
+        for cell in row:
+            tag = "th" if cell["is_header"] else "td"
+            attrs = f" {cell['attrs']}" if cell["attrs"] else ""
+            out += f"<{tag}{attrs}>{cell['text']}</{tag}>"
+        out += "</tr>\n"
+    out += "</tbody></table>\n\n"
+
+    return out
+
+
+def render_table_row() -> str:
+    """Render a table row node (placeholder).
+
+    Returns:
+        Empty string
+    """
+    return ""
+
+
+def render_table_cell() -> str:
+    """Render a table cell node (placeholder).
+
+    Returns:
+        Empty string
+    """
+    return ""
+
+
+def render_table_header() -> str:
+    """Render a table header node (placeholder).
+
+    Returns:
+        Empty string
+    """
+    return ""
+
+
+def render_bold(content: str) -> str:
+    """Render bold mark.
+
+    Args:
+        content: Content to wrap
+
+    Returns:
+        Markdown formatted bold text
+    """
+    if content is None:
+        content = ""
+    return f"{constants.Markdown.BOLD_MARKER}{content}{constants.Markdown.BOLD_MARKER}"
+
+
+def render_italic(content: str) -> str:
+    """Render italic mark.
+
+    Args:
+        content: Content to wrap
+
+    Returns:
+        Markdown formatted italic text
+    """
+    if content is None:
+        content = ""
+    return f"{constants.Markdown.ITALIC_MARKER}{content}{constants.Markdown.ITALIC_MARKER}"
+
+
+def render_strike(content: str) -> str:
+    """Render strike mark.
+
+    Args:
+        content: Content to wrap
+
+    Returns:
+        Markdown formatted strike text
+    """
+    if content is None:
+        content = ""
+    return f"{constants.Markdown.STRIKE_MARKER}{content}{constants.Markdown.STRIKE_MARKER}"
+
+
+def render_code(content: str) -> str:
+    """Render inline code mark.
+
+    Args:
+        content: Content to wrap
+
+    Returns:
+        Markdown formatted code text
+    """
+    if content is None:
+        content = ""
+    return f"{constants.Markdown.CODE_MARKER}{content}{constants.Markdown.CODE_MARKER}"
+
+
+def render_link(node: dict, content: str) -> str:
+    """Render link mark.
+
+    Args:
+        node: Link node
+        content: Link text content
+
+    Returns:
+        Markdown formatted link
+    """
+    attrs = node.get("attrs")
+    href = attrs.get(constants.AttrTypes.HREF, "") if attrs else ""
+    title = attrs.get(constants.AttrTypes.TITLE, "") if attrs else ""
+
+    if title:
+        return f'[{content}]({href} "{title}")'
+    return f"[{content}]({href})"
+
+
+def render_underline(content: str) -> str:
+    """Render underline mark.
+
+    Args:
+        content: Content to wrap
+
+    Returns:
+        HTML formatted underline text
+    """
+    if content is None:
+        content = ""
+    return f"{constants.Markdown.UNDERLINE_HTML_OPEN}{content}{constants.Markdown.UNDERLINE_HTML_CLOSE}"
+
+
+def render_highlight(content: str) -> str:
+    """Render highlight mark.
+
+    Args:
+        content: Content to wrap
+
+    Returns:
+        Markdown formatted highlight text
+    """
+    if content is None:
+        content = ""
+    return f"{constants.Markdown.HIGHLIGHT_MARKER}{content}{constants.Markdown.HIGHLIGHT_MARKER}"
+
+
+def wrap_in_block(prefix: str, content: str) -> str:
+    """Wrap content in a block with prefix.
+
+    Args:
+        prefix: Block prefix
+        content: Content to wrap
+
+    Returns:
+        Wrapped content
+    """
+    if not content:
+        return ""
+
+    lines = content.split("\n")
+    result = []
+    prefix_len = len(prefix) - 1 if prefix.endswith(" ") else len(prefix)
+
+    for i, line in enumerate(lines):
+        if not line:
+            result.append(prefix[:prefix_len] + "\n")
+        else:
+            result.append(prefix + line)
+        if i < len(lines) - 1:
+            result.append("\n")
+
+    return "".join(result)
+
+
+def attrs_to_html_attrs(attrs: dict) -> str:
+    """Convert JSON attrs to HTML attribute string.
+
+    Args:
+        attrs: JSON attributes
+
+    Returns:
+        HTML attribute string like: id="123" name="test"
+    """
+    if not attrs:
+        return ""
+
+    result = []
+    for key, value in attrs.items():
+        if value is not None and isinstance(value, str) and value.strip():
+            result.append(f'{key}="{escape_html(value)}"')
+
+    return " " + " ".join(result) if result else ""
+
+
+def escape_html(text: str) -> str:
+    """Escape HTML special characters.
+
+    Args:
+        text: Raw text
+
+    Returns:
+        Escaped text
+    """
+    if text is None:
+        return ""
+    return (
+        text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")
+    )
+
+
+def escape_markdown_special_chars(text: str) -> str:
+    """Escape Markdown special characters.
+
+    Args:
+        text: Raw text
+
+    Returns:
+        Escaped text
+    """
+    if text is None:
+        return ""
+    return text.replace("\\", "\\\\").replace("`", "\\`").replace("[", "\\[").replace("]", "\\]")
+
+
+def _pad_text(text: str, width: int) -> str:
+    """Pad text to specified width.
+
+    Args:
+        text: Text to pad
+        width: Target width
+
+    Returns:
+        Padded text
+    """
+    if text is None:
+        text = ""
+    if len(text) >= width:
+        return text
+    return text + " " * (width - len(text))
+
+
+def _extract_cell_text(cell_node: dict) -> str:
+    """Extract text from a cell node.
+
+    Args:
+        cell_node: Cell node
+
+    Returns:
+        Cell text
+    """
+    content = cell_node.get("content")
+    if not content:
+        return ""
+
+    parts = []
+    for child in content:
+        if not child:
+            continue
+
+        if child.get("type") == constants.NodeTypes.TEXT:
+            text = child.get("text")
+            if text:
+                parts.append(text)
+        elif "content" in child:
+            nested_text = _extract_cell_text(child)
+            if nested_text:
+                parts.append(nested_text)
+
+    return " ".join(parts).replace(r"\s+", " ").strip()
+
+
+def _extract_cell_content(tool: "TipTapTool", cell_node: dict) -> str:
+    """Extract cell content with support for custom components.
+
+    Args:
+        tool: TipTapTool instance
+        cell_node: Cell node
+
+    Returns:
+        Cell content (HTML or plain text)
+    """
+    content = cell_node.get("content")
+    if not content:
+        return ""
+
+    for child in content:
+        if not child:
+            continue
+        return tool.serialize(child)
+
+    return escape_html(_extract_cell_text(cell_node))
+
+
+def render_fixed_title(content: str) -> str:
+    """Render fixed title.
+
+    Args:
+        content: Content (unused)
+
+    Returns:
+        Double newline
+    """
+    return "\n\n"
+
+
+def render_widget_num(node: dict) -> str:
+    """Render widget number component.
+
+    Args:
+        node: Widget node
+
+    Returns:
+        HTML formatted widget
+    """
+    attrs = node.get("attrs") or {}
+    node_id = attrs.get("id", "")
+    content = node.get("content")
+
+    sb = []
+    if content:
+        for item in content:
+            if not item:
+                continue
+
+            text_json = item.get("text")
+            if not text_json:
+                continue
+
+            try:
+                import json
+
+                params = json.loads(text_json)
+                code = params.get("code", "")
+                col_name = params.get("colName", "")
+                title = params.get("title", "")
+
+                sb.append(
+                    f'<item type="widget" code="{escape_html(code)}" '
+                    f'colName="{escape_html(col_name)}" title="{escape_html(title)}"></item>'
+                )
+            except (json.JSONDecodeError, TypeError):
+                continue
+
+    return f'<anti:html cmp="{constants.NodeTypes.WIDGET_NUM}" id="{escape_html(node_id)}">{"".join(sb)}</anti:html>'
+
+
+def render_dataset_data(node: dict) -> str:
+    """Render dataset data component.
+
+    Args:
+        node: Dataset data node
+
+    Returns:
+        HTML formatted dataset component
+    """
+    attrs = node.get("attrs") or {}
+    node_id = attrs.get("id", "")
+    content = node.get("content")
+
+    sb = []
+    if content:
+        for item in content:
+            if not item:
+                continue
+
+            text_json = item.get("text")
+            if not text_json:
+                continue
+
+            try:
+                import json
+
+                params = json.loads(text_json)
+                code = params.get("code", "")
+                col_name = params.get("colName", "")
+                item_type = params.get("type", "dataset")
+
+                sb.append(
+                    f'<item type="{escape_html(item_type)}" code="{escape_html(code)}" '
+                    f'colName="{escape_html(col_name)}"></item>'
+                )
+            except (json.JSONDecodeError, TypeError):
+                continue
+
+    return f'<anti:html cmp="{constants.NodeTypes.DATASET_DATA}" id="{escape_html(node_id)}">{"".join(sb)}</anti:html>'
+
+
+def render_callout(node: dict, content: str) -> str:
+    """Render callout component.
+
+    Args:
+        node: Callout node
+        content: Rendered child content
+
+    Returns:
+        Markdown formatted callout
+    """
+    attrs = node.get("attrs") or {}
+    ctype = attrs.get(constants.AttrTypes.CALLOUT_TYPE, "info")
+    title = attrs.get(constants.AttrTypes.CALLOUT_TITLE, "") or ""
+    collapsible = attrs.get(constants.AttrTypes.CALLOUT_COLLAPSIBLE, False)
+    collapsed = attrs.get(constants.AttrTypes.CALLOUT_COLLAPSED, False)
+
+    attrs_str = f'type="{ctype}"'
+    if title:
+        attrs_str += f' title="{escape_markdown_special_chars(title)}"'
+    if collapsible:
+        attrs_str += ' collapsible="true"'
+        if collapsed:
+            attrs_str += ' collapsed="true"'
+
+    return f'<anti:html cmp="{constants.NodeTypes.CALLOUT}" {attrs_str}>\n{content}\n</anti:html>\n'
+
+
+def render_mention(node: dict) -> str:
+    """Render mention node.
+
+    Args:
+        node: Mention node
+
+    Returns:
+        HTML formatted mention
+    """
+    attrs = node.get("attrs") or {}
+    mention_type = attrs.get("type", "")
+    node_id = node.get("id", "")
+    code = attrs.get("id", "")
+    sub_type = attrs.get("subType", "")
+
+    import uuid
+
+    if not node_id:
+        node_id = str(uuid.uuid4())
+
+    if mention_type == "ontology":
+        return (
+            f'<mention id="{escape_html(node_id)}" type="report" '
+            f'sub-type="ontology" code="{escape_html(code)}"></mention>'
+        )
+
+    data = attrs.get("data")
+
+    mention_tag = f'<mention id="{escape_html(node_id)}" type="{escape_html(mention_type)}" code="{escape_html(code)}"'
+
+    if sub_type:
+        mention_tag += f' subType="{escape_html(sub_type)}"'
+    elif mention_type == "report":
+        mention_tag += ' subType="doc"'
+
+    if data:
+        import json
+
+        data_str = json.dumps(data) if isinstance(data, dict) else str(data)
+        mention_tag += f' data="{escape_html(data_str)}"'
+
+    mention_tag += "></mention>"
+    return mention_tag
+
+
+def render_single_item_custom(node: dict, html_tag: str, inline: bool = False) -> str:
+    """Render single item custom node.
+
+    Args:
+        node: Node
+        html_tag: HTML tag to use
+        inline: Whether to render inline
+
+    Returns:
+        HTML formatted node
+    """
+    attrs = node.get("attrs") or {}
+
+    html_attrs = attrs_to_html_attrs(attrs)
+
+    text = ""
+    content = node.get("content")
+    if content:
+        first_item = content[0] if content else {}
+        text = first_item.get("text", "") or ""
+
+    result = f"<{html_tag}{html_attrs}>{text}</{html_tag}>"
+
+    if not inline:
+        result += "\n"
+
+    return result
+
+
+def render_mermaid(node: dict) -> str:
+    """Render mermaid chart node.
+
+    Args:
+        node: Mermaid node
+
+    Returns:
+        Markdown formatted mermaid code block
+    """
+    attrs = node.get("attrs") or {}
+    chart_type = attrs.get(constants.AttrTypes.CHART_TYPE, "") or ""
+    title = attrs.get(constants.AttrTypes.TITLE, "") or ""
+    content = attrs.get(constants.AttrTypes.CODE, "") or ""
+
+    mermaid_content = "```mermaid\n"
+    if chart_type:
+        mermaid_content += chart_type
+        if title:
+            mermaid_content += f' title "{title}"'
+    if content:
+        if mermaid_content.endswith("\n"):
+            mermaid_content += "\n"
+        else:
+            mermaid_content += "\n"
+        mermaid_content += content
+
+    return mermaid_content + "\n```\n"