dataops-sdk 0.3.0__py3-none-any.whl

dataops_sdk/tiptap/parse_utils.py

@@ -0,0 +1,889 @@
+"""TipTap Markdown parsing utilities.
+
+Provides functions to parse Markdown text into TipTap JSON format.
+"""
+
+import re
+from typing import Any
+
+from dataops_sdk.tiptap import constants
+
+
+def create_doc(content: list[dict] | None = None) -> dict:
+    """Create a doc node.
+
+    Args:
+        content: List of content nodes
+
+    Returns:
+        TipTap doc node
+    """
+    doc = {"type": constants.NodeTypes.DOC}
+    if content:
+        doc["content"] = content
+    return doc
+
+
+def create_node(
+    node_type: str,
+    attrs: dict | None = None,
+    content: list[dict] | None = None,
+) -> dict:
+    """Create a generic node.
+
+    Args:
+        node_type: Type of the node
+        attrs: Node attributes
+        content: Child content nodes
+
+    Returns:
+        TipTap node
+    """
+    node: dict[str, Any] = {"type": node_type}
+    if attrs:
+        node["attrs"] = attrs
+    if content:
+        node["content"] = content
+    return node
+
+
+def create_text_node(text: str, marks: list[dict] | None = None) -> dict:
+    """Create a text node.
+
+    Args:
+        text: Text content
+        marks: List of marks to apply
+
+    Returns:
+        TipTap text node
+    """
+    node: dict[str, Any] = {"type": constants.NodeTypes.TEXT, "text": text or ""}
+    if marks:
+        node["marks"] = marks
+    return node
+
+
+def parse_paragraph(tokens: list[dict] | None = None) -> dict:
+    """Parse a paragraph node.
+
+    Args:
+        tokens: Child tokens
+
+    Returns:
+        TipTap paragraph node
+    """
+    node = create_node(constants.NodeTypes.PARAGRAPH)
+    if tokens:
+        node["content"] = tokens
+    return node
+
+
+def parse_heading(tokens: list[dict], level: int) -> dict:
+    """Parse a heading node.
+
+    Args:
+        tokens: Child tokens
+        level: Heading level (1-6)
+
+    Returns:
+        TipTap heading node
+    """
+    return create_node(
+        constants.NodeTypes.HEADING,
+        attrs={constants.AttrTypes.LEVEL: level},
+        content=tokens,
+    )
+
+
+def parse_text(text: str) -> dict:
+    """Parse a text node.
+
+    Args:
+        text: Text content
+
+    Returns:
+        TipTap text node
+    """
+    return create_text_node(text, None)
+
+
+def parse_code_block(code: str, language: str | None = None) -> dict:
+    """Parse a code block node.
+
+    Args:
+        code: Code content
+        language: Code language
+
+    Returns:
+        TipTap code block node
+    """
+    node = create_node(constants.NodeTypes.CODE_BLOCK)
+    content = [create_text_node(code)]
+    node["content"] = content
+    if language:
+        node["attrs"] = {constants.AttrTypes.LANGUAGE: language}
+    return node
+
+
+def parse_blockquote(tokens: list[dict] | None = None) -> dict:
+    """Parse a blockquote node.
+
+    Args:
+        tokens: Child tokens
+
+    Returns:
+        TipTap blockquote node
+    """
+    node = create_node(constants.NodeTypes.BLOCKQUOTE)
+    if tokens:
+        node["content"] = tokens
+    return node
+
+
+def parse_bullet_list(items: list[dict] | None = None) -> dict:
+    """Parse a bullet list node.
+
+    Args:
+        items: List items
+
+    Returns:
+        TipTap bullet list node
+    """
+    node = create_node(constants.NodeTypes.BULLET_LIST)
+    if items:
+        node["content"] = items
+    return node
+
+
+def parse_ordered_list(items: list[dict] | None = None) -> dict:
+    """Parse an ordered list node.
+
+    Args:
+        items: List items
+
+    Returns:
+        TipTap ordered list node
+    """
+    node = create_node(constants.NodeTypes.ORDERED_LIST)
+    if items:
+        node["content"] = items
+    return node
+
+
+def parse_task_list(items: list[dict] | None = None) -> dict:
+    """Parse a task list node.
+
+    Args:
+        items: Task items
+
+    Returns:
+        TipTap task list node
+    """
+    node = create_node(constants.NodeTypes.TASK_LIST)
+    if items:
+        node["content"] = items
+    return node
+
+
+def parse_task_item(text: str, checked: bool) -> dict:
+    """Parse a task item node.
+
+    Args:
+        text: Task item text
+        checked: Whether the task is checked
+
+    Returns:
+        TipTap task item node
+    """
+    node = create_node(
+        constants.NodeTypes.TASK_ITEM,
+        attrs={constants.AttrTypes.CHECKED: checked},
+        content=[create_text_node(text)],
+    )
+    return node
+
+
+def parse_list_item(tokens: list[dict] | None = None) -> dict:
+    """Parse a list item node.
+
+    Args:
+        tokens: Child tokens
+
+    Returns:
+        TipTap list item node
+    """
+    node = create_node(constants.NodeTypes.LIST_ITEM)
+    if tokens:
+        node["content"] = tokens
+    return node
+
+
+def parse_horizontal_rule() -> dict:
+    """Parse a horizontal rule node.
+
+    Returns:
+        TipTap horizontal rule node
+    """
+    return create_node(constants.NodeTypes.HORIZONTAL_RULE)
+
+
+def parse_hard_break() -> dict:
+    """Parse a hard break node.
+
+    Returns:
+        TipTap hard break node
+    """
+    return create_node(constants.NodeTypes.HARD_BREAK)
+
+
+def parse_image(src: str, alt: str = "", title: str | None = None) -> dict:
+    """Parse an image node.
+
+    Args:
+        src: Image source URL
+        alt: Alt text
+        title: Image title
+
+    Returns:
+        TipTap image node
+    """
+    return create_node(
+        constants.NodeTypes.IMAGE,
+        attrs={
+            constants.AttrTypes.SRC: src or "",
+            constants.AttrTypes.ALT: alt or "",
+            constants.AttrTypes.TITLE: title or "",
+        },
+    )
+
+
+def parse_table(rows: list[dict] | None = None) -> dict:
+    """Parse a table node.
+
+    Args:
+        rows: Table rows
+
+    Returns:
+        TipTap table node
+    """
+    node = create_node(constants.NodeTypes.TABLE)
+    if rows:
+        node["content"] = rows
+    return node
+
+
+def parse_table_row(cells: list[dict] | None = None) -> dict:
+    """Parse a table row node.
+
+    Args:
+        cells: Row cells
+
+    Returns:
+        TipTap table row node
+    """
+    node = create_node(constants.NodeTypes.TABLE_ROW)
+    if cells:
+        node["content"] = cells
+    return node
+
+
+def parse_table_cell(tokens: list[dict] | None = None) -> dict:
+    """Parse a table cell node.
+
+    Args:
+        tokens: Cell content tokens
+
+    Returns:
+        TipTap table cell node
+    """
+    node = create_node(constants.NodeTypes.TABLE_CELL)
+    if tokens:
+        node["content"] = tokens
+    return node
+
+
+def parse_table_header(tokens: list[dict] | None = None) -> dict:
+    """Parse a table header node.
+
+    Args:
+        tokens: Header content tokens
+
+    Returns:
+        TipTap table header node
+    """
+    node = create_node(constants.NodeTypes.TABLE_HEADER)
+    if tokens:
+        node["content"] = tokens
+    return node
+
+
+def parse_callout(
+    callout_type: str,
+    title: str | None,
+    content: list[str],
+    collapsible: bool,
+    collapsed: bool,
+) -> dict:
+    """Parse a callout node.
+
+    Args:
+        callout_type: Callout type (info/warning/success/error)
+        title: Callout title
+        content: Content lines
+        collapsible: Whether callout is collapsible
+        collapsed: Whether callout is collapsed
+
+    Returns:
+        TipTap callout node
+    """
+    node = create_node(
+        constants.NodeTypes.CALLOUT,
+        attrs={
+            constants.AttrTypes.CALLOUT_TYPE: callout_type or "info",
+            constants.AttrTypes.CALLOUT_TITLE: title or "",
+            constants.AttrTypes.CALLOUT_COLLAPSIBLE: collapsible,
+            constants.AttrTypes.CALLOUT_COLLAPSED: collapsed,
+        },
+    )
+
+    if content:
+        content_nodes = []
+        current_para: list[str] = []
+
+        for line in content:
+            if not line.strip():
+                if current_para:
+                    content_nodes.append(
+                        parse_paragraph(parse_inline_formatting(" ".join(current_para).strip()))
+                    )
+                    current_para = []
+            else:
+                current_para.append(line)
+
+        if current_para:
+            content_nodes.append(
+                parse_paragraph(parse_inline_formatting(" ".join(current_para).strip()))
+            )
+
+        if content_nodes:
+            node["content"] = content_nodes
+
+    return node
+
+
+def parse_columns(
+    count: int,
+    gap: str | None,
+    columns_content: list[list[dict]],
+) -> dict:
+    """Parse a columns node.
+
+    Args:
+        count: Number of columns
+        gap: Gap between columns
+        columns_content: Content for each column
+
+    Returns:
+        TipTap columns node
+    """
+    node = create_node(
+        constants.NodeTypes.COLUMNS,
+        attrs={
+            constants.AttrTypes.COLUMNS_COUNT: count,
+            constants.AttrTypes.COLUMNS_GAP: gap,
+        },
+    )
+
+    content = []
+    column_width = 100 / max(count, 1)
+
+    for i, col_content in enumerate(columns_content):
+        column_node = create_node(
+            constants.NodeTypes.COLUMN,
+            attrs={constants.AttrTypes.COLUMN_WIDTH: f"{column_width:.2f}%"},
+        )
+        if col_content:
+            column_node["content"] = col_content
+        content.append(column_node)
+
+        if i < len(columns_content) - 1:
+            content.append(create_node(constants.NodeTypes.COLUMN_RESIZER))
+
+    if content:
+        node["content"] = content
+
+    return node
+
+
+def parse_markdown(markdown: str) -> dict:
+    """Parse Markdown text to TipTap JSON document.
+
+    Args:
+        markdown: Markdown text
+
+    Returns:
+        TipTap JSON document
+    """
+    if not markdown:
+        return create_doc([])
+
+    content = _parse_markdown_content(markdown.strip())
+    return create_doc(content)
+
+
+def _parse_markdown_content(markdown: str) -> list[dict]:
+    """Parse Markdown content into node list.
+
+    Args:
+        markdown: Markdown text
+
+    Returns:
+        List of TipTap nodes
+    """
+    content: list[dict] = []
+    lines = markdown.split("\n")
+    i = 0
+
+    while i < len(lines):
+        line = lines[i]
+
+        if not line.strip():
+            i += 1
+            continue
+
+        # Parse headings
+        heading_match = re.match(r"^(#{1,6})\s+(.+)$", line)
+        if heading_match:
+            level = len(heading_match.group(1))
+            text = heading_match.group(2).strip()
+            content.append(parse_heading(_parse_inline_formatting(text), level))
+            i += 1
+            continue
+
+        # Parse horizontal rule
+        if re.match(r"^(\*\s*\*\s*\*|-{3,}|_{3,})$", line.strip()):
+            content.append(parse_horizontal_rule())
+            i += 1
+            continue
+
+        # Parse code block
+        code_match = re.match(r"^```(\w+)?\s*$", line)
+        if code_match:
+            language = code_match.group(1)
+            code_lines: list[str] = []
+            i += 1
+
+            while i < len(lines) and not re.match(r"^```\s*$", lines[i]):
+                code_lines.append(lines[i])
+                i += 1
+
+            code = "\n".join(code_lines)
+            content.append(parse_code_block(code, language))
+            i += 1
+            continue
+
+        # Parse blockquote
+        if line.strip().startswith(">"):
+            quote_lines: list[str] = []
+            quote_text = line.strip()[1:].strip()
+            if quote_text:
+                quote_lines.append(quote_text)
+            i += 1
+
+            while i < len(lines) and lines[i].strip().startswith(">"):
+                current_line = lines[i].strip()[1:].strip()
+                if current_line:
+                    quote_lines.append(current_line)
+                i += 1
+
+            joined_text = "\n".join(quote_lines)
+            content.append(
+                parse_blockquote([parse_paragraph(_parse_inline_formatting(joined_text))])
+            )
+            continue
+
+        # Parse lists
+        list_match = re.match(r"^(\s*)([-+*]|\d+\.)\s+(.+)$", line)
+        if list_match:
+            indent = list_match.group(1)
+            list_type = list_match.group(2)
+            item_text = list_match.group(3)
+
+            # Detect task list
+            task_match = re.match(r"^(\[([ xX])\])\s+(.+)$", item_text)
+            is_task = bool(task_match)
+
+            list_items: list[dict] = []
+            current_line = i
+
+            while current_line < len(lines):
+                current = lines[current_line]
+                current_matcher = re.match(r"^(\s*)([-+*]|\d+\.)\s+(.+)$", current)
+
+                if not current_matcher:
+                    break
+
+                this_indent = current_matcher.group(1)
+                this_list_type = current_matcher.group(2)
+                this_item_text = current_matcher.group(3)
+
+                # Check if same list
+                if len(this_indent) < len(indent):
+                    break
+
+                if is_task:
+                    current_task_match = re.match(r"^(\[([ xX])\])\s+(.+)$", this_item_text)
+                    if current_task_match:
+                        checked = current_task_match.group(2).lower() == "x"
+                        task_text = current_task_match.group(3)
+                        list_items.append(parse_task_item(task_text, checked))
+                    else:
+                        break
+                else:
+                    current_task_match = re.match(r"^(\[([ xX])\])\s+(.+)$", this_item_text)
+                    if not current_task_match:
+                        list_items.append(
+                            parse_list_item(
+                                [parse_paragraph(_parse_inline_formatting(this_item_text))]
+                            )
+                        )
+                    else:
+                        break
+
+                current_line += 1
+
+            if is_task:
+                content.append(parse_task_list(list_items))
+            else:
+                if re.match(r"^[-+*]$", list_type):
+                    content.append(parse_bullet_list(list_items))
+                else:
+                    content.append(parse_ordered_list(list_items))
+
+            i = current_line
+            continue
+
+        # Parse table
+        table_match = re.match(r"^\|(.+)\|$", line)
+        if table_match:
+            table_rows: list[dict] = []
+            current_line = i
+
+            while current_line < len(lines):
+                current = lines[current_line]
+                row_match = re.match(r"^\|(.+)\|$", current)
+
+                if not row_match:
+                    break
+
+                row_content = row_match.group(1)
+
+                # Skip separator row
+                if re.match(r"^[\s\-:|]+$", row_content):
+                    current_line += 1
+                    continue
+
+                # Parse cells
+                cells = row_content.split("|")
+                row_cells: list[dict] = []
+                is_header = len(table_rows) == 0
+
+                for cell_text in cells:
+                    trimmed_cell = cell_text.strip()
+                    cell_type = (
+                        constants.NodeTypes.TABLE_HEADER
+                        if is_header
+                        else constants.NodeTypes.TABLE_CELL
+                    )
+                    row_cells.append(
+                        create_node(cell_type, content=_parse_inline_formatting(trimmed_cell))
+                    )
+
+                table_rows.append(parse_table_row(row_cells))
+                current_line += 1
+
+            if table_rows:
+                content.append(parse_table(table_rows))
+
+            i = current_line
+            continue
+
+        # Parse <anti:html cmp="..."> custom components
+        anti_html_match = re.match(r"^<anti:html\s+cmp=\"(\w+)\"(.*)>$", line)
+        if anti_html_match:
+            cmp_type = anti_html_match.group(1)
+            attrs = anti_html_match.group(2)
+
+            if cmp_type == "columns":
+                # Parse <anti:html type="columns" count="n" gap="m">
+                count = 2
+                gap = None
+
+                if attrs:
+                    count_match = re.search(r"count=\"(\d+)\"", attrs)
+                    if count_match:
+                        count = int(count_match.group(1))
+                    gap_match = re.search(r"gap=\"([^\"]*)\"", attrs)
+                    if gap_match:
+                        gap = gap_match.group(1)
+
+                # Parse each <column> content
+                column_lines: list[list[str]] = []
+                i += 1
+
+                while i < len(lines):
+                    current_line_text = lines[i].strip()
+
+                    if current_line_text == "</anti:html>":
+                        break
+
+                    column_match = re.match(r"^<column(?:\s+(.+))?>$", current_line_text)
+                    if column_match:
+                        col_content: list[str] = []
+                        i += 1
+
+                        while i < len(lines) and lines[i].strip() != "</column>":
+                            col_content.append(lines[i])
+                            i += 1
+
+                        column_lines.append(col_content)
+                        i += 1
+                        continue
+
+                    i += 1
+
+                # Parse each column content to nodes
+                columns_content: list[list[dict]] = []
+                for col_lines in column_lines:
+                    col_markdown = "\n".join(col_lines)
+                    if col_markdown.strip():
+                        col_nodes = _parse_markdown_content(col_markdown)
+                        columns_content.append(col_nodes)
+                    else:
+                        columns_content.append([])
+
+                content.append(parse_columns(count, gap, columns_content))
+                i += 1
+                continue
+
+            elif cmp_type == "callout":
+                # Callout <anti:html cmp="callout" type="xxx" title="xxx" collapsible="true" collapsed="true">
+                callout_type = "info"
+                title = None
+                collapsible = False
+                collapsed = False
+
+                if attrs:
+                    type_match = re.search(r"type=\"([^\"]*)\"", attrs)
+                    if type_match:
+                        callout_type = type_match.group(1)
+                    title_match = re.search(r"title=\"([^\"]*)\"", attrs)
+                    if title_match:
+                        title = title_match.group(1)
+                    collapsible_match = re.search(r"collapsible=\"([^\"]*)\"", attrs)
+                    if collapsible_match:
+                        collapsible = collapsible_match.group(1).lower() == "true"
+                    collapsed_match = re.search(r"collapsed=\"([^\"]*)\"", attrs)
+                    if collapsed_match:
+                        collapsed = collapsed_match.group(1).lower() == "true"
+
+                callout_content: list[str] = []
+                i += 1
+
+                while i < len(lines) and lines[i].strip() != "</anti:html>":
+                    callout_content.append(lines[i])
+                    i += 1
+
+                i += 1
+                content.append(
+                    parse_callout(callout_type, title, callout_content, collapsible, collapsed)
+                )
+                continue
+
+        # Parse paragraph
+        para_lines: list[str] = [line]
+        i += 1
+
+        while (
+            i < len(lines)
+            and lines[i].strip()
+            and not re.match(r"^(#{1,6})\s+", lines[i])
+            and not re.match(r"^(\*\s*\*\s*\*|-{3,}|_{3,})$", lines[i].strip())
+            and not re.match(r"^```", lines[i])
+            and not re.match(r"^>\s+", lines[i])
+            and not re.match(r"^(\s*)([-+*]|\d+\.)\s+", lines[i])
+            and not re.match(r"^\|(.+)\|$", lines[i])
+            and not re.match(r"^<anti:html\s+", lines[i])
+        ):
+            para_lines.append(lines[i])
+            i += 1
+
+        para_text = " ".join(para_lines)
+        content.append(parse_paragraph(_parse_inline_formatting(para_text)))
+
+    return content
+
+
+def _parse_inline_formatting(text: str) -> list[dict]:
+    """Parse inline formatting (bold, italic, etc.).
+
+    Args:
+        text: Raw text
+
+    Returns:
+        List of text nodes with marks
+    """
+    result: list[dict] = []
+    pos = 0
+
+    # Priority order: code > link > highlight > bold > italic > strike > underline
+    patterns = [
+        (r"`([^`]+)`", "code"),
+        (r"\[([^\]]+)\]\(([^)]+)\)", "link"),
+        (r"==([^=]+)==", "highlight"),
+        (r"\*\*([^*]+)\*\*", "bold"),
+        (r"(?<!\*)\*(?!\*)([^*]+)(?<!\*)\*(?!\*)", "italic"),
+        (r"~~([^~]+)~~", "strike"),
+        (r"__([^_]+)__", "underline"),
+    ]
+
+    while pos < len(text):
+        best_match = None
+        best_pattern_index = -1
+        best_start = len(text)
+
+        for j, (pattern, mark_type) in enumerate(patterns):
+            matcher = re.match(pattern, text[pos:])
+            if matcher:
+                if matcher.start() < best_start:
+                    best_match = matcher
+                    best_pattern_index = j
+                    best_start = matcher.start()
+
+        if best_match is None:
+            result.append(create_text_node(text[pos:], None))
+            break
+
+        if best_match.start() > 0:
+            result.append(create_text_node(text[pos : pos + best_match.start()], None))
+
+        matched_text = best_match.group(1)
+        start_pos = pos + best_match.start()
+        mark_type = patterns[best_pattern_index][1]
+
+        if mark_type == "link":
+            link_text = best_match.group(1)
+            link_url = best_match.group(2)
+            link_node = create_text_node(link_text, None)
+            link_node["marks"] = [
+                {
+                    "type": constants.MarkTypes.LINK,
+                    "attrs": {
+                        constants.AttrTypes.HREF: link_url,
+                        constants.AttrTypes.TITLE: "",
+                    },
+                }
+            ]
+            result.append(link_node)
+        elif mark_type == "code":
+            code_node = create_text_node(matched_text, None)
+            code_node["marks"] = [{"type": constants.MarkTypes.CODE}]
+            result.append(code_node)
+        else:
+            marked_node = create_text_node(matched_text, None)
+            marked_node["marks"] = [{"type": mark_type}]
+            result.append(marked_node)
+
+        pos = start_pos + best_match.end()
+
+    if not result:
+        result.append(create_text_node(text, None))
+
+    # Merge adjacent plain text nodes
+    merged_result: list[dict] = []
+    for node in result:
+        node_text = node.get("text")
+        node_marks = node.get("marks")
+
+        if node_text and (node_marks is None or len(node_marks) == 0):
+            if merged_result:
+                last_node = merged_result[-1]
+                last_text = last_node.get("text")
+                last_marks = last_node.get("marks")
+
+                if last_text and (last_marks is None or len(last_marks) == 0):
+                    last_node["text"] = last_text + node_text
+                    continue
+
+        merged_result.append(node)
+
+    return merged_result
+
+
+def parse_fallback(token_type: str, token: dict) -> dict | None:
+    """Fallback parser for handling unhandled types.
+
+    Args:
+        token_type: Token type
+        token: Token data
+
+    Returns:
+        Parsed node or None
+    """
+    if token_type == "paragraph":
+        return parse_paragraph(token.get("tokens"))
+    elif token_type == "heading":
+        return parse_heading(token.get("tokens"), token.get("depth", 1))
+    elif token_type == "text":
+        return parse_text(token.get("text", ""))
+    return None
+
+
+def pick_tags(content: str) -> dict[str, list[dict]]:
+    """Extract all HTML tags from content.
+
+    Args:
+        content: HTML content
+
+    Returns:
+        Dict mapping tag names to list of tag objects
+    """
+    result: dict[str, list[dict]] = {}
+
+    if not content or not content.strip():
+        return result
+
+    tag_pattern = r"<(\w+)([^>]*)>(.*?)</\1>|<(\w+)([^>]*)/>"
+    pattern = re.compile(tag_pattern, re.DOTALL)
+    matcher = pattern.finditer(content)
+
+    for match in matcher:
+        if match.group(1) is not None:
+            tag_name = match.group(1)
+            tag_attrs = match.group(2)
+            tag_content = match.group(3)
+        else:
+            tag_name = match.group(4)
+            tag_attrs = match.group(5)
+            tag_content = None
+
+        tag_obj: dict[str, Any] = {}
+
+        attr_pattern = re.compile(r'(\w+)="([^"]*)"|(\w+)=' "'([^']*)'")
+        attr_matcher = attr_pattern.finditer(tag_attrs or "")
+
+        for attr_match in attr_matcher:
+            attr_name = attr_match.group(1) or attr_match.group(3)
+            attr_value = attr_match.group(2) or attr_match.group(4)
+            if attr_name:
+                tag_obj[attr_name] = attr_value
+
+        if tag_content and tag_content.strip():
+            tag_obj["content"] = tag_content.strip()
+
+        if tag_name:
+            if tag_name not in result:
+                result[tag_name] = []
+            result[tag_name].append(tag_obj)
+
+    return result