licos-dev-sdk 0.3.0__tar.gz → 0.3.2__tar.gz

{licos_dev_sdk-0.3.0 → licos_dev_sdk-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: licos-dev-sdk
-Version: 0.3.0
+Version: 0.3.2
 Summary: LICOS Dev SDK - file generation and model capability clients
 Requires-Python: >=3.10
 Requires-Dist: beautifulsoup4>=4.12

{licos_dev_sdk-0.3.0 → licos_dev_sdk-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-dev-sdk"
-version = "0.3.0"
+version = "0.3.2"
 description = "LICOS Dev SDK - file generation and model capability clients"
 requires-python = ">=3.10"
 dependencies = [

{licos_dev_sdk-0.3.0 → licos_dev_sdk-0.3.2}/src/licos_dev_sdk/document.py

@@ -1,17 +1,18 @@
-"""Document generation — PDF, DOCX."""
-
-from __future__ import annotations
-
-from typing import Any
-
+"""Document generation — PDF, DOCX."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
 from ._utils import resolve_output_path
-
-
+
+
 def create_pdf(content: str, filename: str, *, content_type: str = "markdown",
                output_dir: str | None = None, page_size: str = "A4",
                theme: str = "formal-blue", title: str | None = None,
                margin: str = "20mm") -> str:
-    """Generate a PDF file from Markdown or HTML. Returns absolute path."""
+    """Generate a PDF file from Markdown or HTML. Returns absolute path."""
     from weasyprint import HTML
     from .document_common import build_pdf_html
 
@@ -25,14 +26,15 @@ def create_pdf(content: str, filename: str, *, content_type: str = "markdown",
         title=title,
     )
     HTML(string=full_html, base_url=str(path.parent)).write_pdf(str(path))
-    return str(path.resolve())
-
-
+    return str(path.resolve())
+
+
 def create_docx(content: str, filename: str, *, content_type: str = "markdown",
                 output_dir: str | None = None, font_name: str = "Microsoft YaHei",
                 font_size: int = 11, theme: str = "formal-blue",
                 title: str | None = None, header: str | None = None,
-                footer: str | None = None, include_toc: bool = False) -> str:
+                footer: str | None = None, include_toc: bool = False,
+                asset_base_path: str | None = None) -> str:
     """Generate a styled DOCX from Markdown or HTML. Returns absolute path."""
     from .document_docx import render_docx
 
@@ -48,25 +50,25 @@ def create_docx(content: str, filename: str, *, content_type: str = "markdown",
         header=header,
         footer=footer,
         include_toc=include_toc,
-        base_path=path.parent,
+        base_path=Path(asset_base_path) if asset_base_path else path.parent,
     )
-
-
-def create_docx_from_template(template_path: str, data: dict[str, Any], filename: str, *,
-                              output_dir: str | None = None) -> str:
-    """Render a DOCX template with Jinja-style placeholders.
-
-    The template must be a `.docx` file. Placeholders use docxtpl syntax, for example
-    `{{ customer_name }}` or `{% for item in items %}...{% endfor %}`.
-    Returns the absolute path of the generated document.
-    """
-    if not isinstance(data, dict):
-        raise TypeError("data must be a dict")
-
-    from docxtpl import DocxTemplate
-
-    path = resolve_output_path(filename, ".docx", output_dir)
-    doc = DocxTemplate(template_path)
-    doc.render(data)
-    doc.save(str(path))
-    return str(path.resolve())
+
+
+def create_docx_from_template(template_path: str, data: dict[str, Any], filename: str, *,
+                              output_dir: str | None = None) -> str:
+    """Render a DOCX template with Jinja-style placeholders.
+
+    The template must be a `.docx` file. Placeholders use docxtpl syntax, for example
+    `{{ customer_name }}` or `{% for item in items %}...{% endfor %}`.
+    Returns the absolute path of the generated document.
+    """
+    if not isinstance(data, dict):
+        raise TypeError("data must be a dict")
+
+    from docxtpl import DocxTemplate
+
+    path = resolve_output_path(filename, ".docx", output_dir)
+    doc = DocxTemplate(template_path)
+    doc.render(data)
+    doc.save(str(path))
+    return str(path.resolve())

{licos_dev_sdk-0.3.0 → licos_dev_sdk-0.3.2}/src/licos_dev_sdk/document_docx.py

@@ -17,11 +17,23 @@ from docx.oxml.ns import qn
 from docx.shared import Cm, Mm, Pt, RGBColor
 
 from .document_common import markdown_to_html, resolve_document_theme
+from .document_docx_layout import (
+    box_side as _box_side,
+    cell_vertical_alignment as _cell_vertical_alignment,
+    css_font_size as _css_font_size,
+    css_length_to_cm as _css_length_to_cm,
+    css_length_to_points as _css_length_to_points,
+    css_length_to_twips as _css_length_to_twips,
+    first_font as _first_font,
+    table_alignment as _table_alignment,
+    table_cell_placements as _table_cell_placements,
+    word_safe_fragments as _word_safe_fragments,
+)
 
 
 _INHERITED_CSS = {
     "color", "font-family", "font-size", "font-style", "font-weight",
-    "text-align", "text-decoration", "line-height",
+    "letter-spacing", "text-align", "text-decoration", "line-height",
 }
 _COLOR_NAMES = {
     "black": "000000", "white": "FFFFFF", "red": "FF0000", "blue": "0000FF",
@@ -214,10 +226,11 @@ class _DocxRenderer:
                 self.render_inline(paragraph, tag)
             else:
                 self.render_blocks(tag)
-            fill = _parse_color(style.get("background-color") or style.get("background"))
+            fill = _background_color(style)
             if fill:
                 for paragraph in self.doc.paragraphs[before:]:
                     _set_paragraph_shading(paragraph, fill)
+            _apply_container_box(self.doc.paragraphs[before:], style)
             if _has_page_break_after(style):
                 _add_page_break(self.doc)
         else:
@@ -239,22 +252,21 @@ class _DocxRenderer:
         elif level == 2:
             _set_paragraph_border(p, self.theme["secondary"], side="left", size="20")
             p.paragraph_format.left_indent = Cm(0.18)
-        run = p.add_run(text)
+        self._append_text(p, text, tag)
         if tag is not None:
-            self._apply_run_style(run, tag)
+            self._apply_paragraph_style(p, tag)
 
     def render_inline(self, paragraph, node: Tag | NavigableString) -> None:
         if isinstance(node, Comment):
             return
         if isinstance(node, NavigableString):
-            paragraph.add_run(str(node))
+            self._append_text(paragraph, str(node))
             return
         for child in node.children:
             if isinstance(child, Comment):
                 continue
             if isinstance(child, NavigableString):
-                run = paragraph.add_run(str(child))
-                self._apply_run_style(run, node)
+                self._append_text(paragraph, str(child), node)
             elif not isinstance(child, Tag):
                 continue
             elif child.name == "br":
@@ -276,18 +288,19 @@ class _DocxRenderer:
         for li in tag.find_all("li", recursive=False):
             p = self.doc.add_paragraph(style=style_name)
             p.paragraph_format.left_indent = Cm(0.65 + level * 0.5)
+            self._apply_paragraph_style(p, li)
             for child in li.children:
                 if isinstance(child, Comment):
                     continue
                 if isinstance(child, Tag) and child.name in {"ul", "ol"}:
                     continue
                 if isinstance(child, (Tag, NavigableString)):
-                    self.render_inline(p, child) if isinstance(child, Tag) else p.add_run(str(child))
+                    self.render_inline(p, child) if isinstance(child, Tag) else self._append_text(p, str(child), li)
             for nested in li.find_all(["ul", "ol"], recursive=False):
                 self._render_list(nested, ordered=nested.name == "ol", level=level + 1)
 
     def _render_table(self, tag: Tag) -> None:
-        rows = tag.find_all("tr")
+        rows = [row for row in tag.find_all("tr") if row.find_parent("table") is tag]
         if not rows:
             return
         caption = tag.find("caption", recursive=False)
@@ -297,35 +310,49 @@ class _DocxRenderer:
             run = paragraph.add_run(caption.get_text(" ", strip=True))
             run.bold = True
             _set_run_font(run, self.font_name, self.font_size, self.theme["primary"])
-        col_count = max(sum(max(int(cell.get("colspan", 1)), 1) for cell in row.find_all(["th", "td"], recursive=False)) for row in rows)
+        placements, col_count = _table_cell_placements(rows)
         table = self.doc.add_table(rows=len(rows), cols=col_count)
         table.style = "Table Grid"
-        table.autofit = True
+        table_style = self._style(tag)
+        table.alignment = _table_alignment(table_style.get("text-align"))
+        column_widths = _table_column_widths(tag, col_count)
+        table.autofit = not any(column_widths)
+        for index, width in enumerate(column_widths):
+            if width:
+                table.columns[index].width = Cm(width)
+
         for row_index, source_row in enumerate(rows):
-            target_col = 0
-            cells = source_row.find_all(["th", "td"], recursive=False)
-            for source_cell in cells:
-                if target_col >= col_count:
-                    break
-                colspan = max(int(source_cell.get("colspan", 1)), 1)
+            _prevent_table_row_split(table.rows[row_index])
+            if source_row.find_parent("thead") is not None:
+                _repeat_table_header(table.rows[row_index])
+            row_style = self._style(source_row)
+            for source_cell, target_col, rowspan, colspan in placements[row_index]:
+                bottom = min(row_index + rowspan - 1, len(rows) - 1)
+                right = min(target_col + colspan - 1, col_count - 1)
                 target = table.cell(row_index, target_col)
-                if colspan > 1 and target_col + colspan <= col_count:
-                    target = target.merge(table.cell(row_index, target_col + colspan - 1))
+                if bottom > row_index or right > target_col:
+                    target = target.merge(table.cell(bottom, right))
                 target.text = ""
                 p = target.paragraphs[0]
+                self._apply_paragraph_style(p, source_cell, include_box_model=False)
                 self.render_inline(p, source_cell)
                 cell_style = self._style(source_cell)
-                is_header = source_cell.name == "th" or row_index == 0
-                fill = _parse_color(cell_style.get("background-color") or cell_style.get("background"))
+                is_header = source_cell.name == "th" or source_row.find_parent("thead") is not None
+                fill = _background_color(cell_style) or _background_color(row_style)
                 if not fill:
                     fill = self.theme["primary"] if is_header else (self.theme["table_alt"] if row_index % 2 else "FFFFFF")
                 _set_cell_shading(target, fill)
-                _set_cell_vertical_alignment(target, "center")
+                _set_cell_vertical_alignment(target, _cell_vertical_alignment(cell_style.get("vertical-align")))
+                _set_cell_margins(target, cell_style)
+                _set_cell_borders(target, cell_style, self.theme["secondary"])
+                width = _css_length_to_cm(cell_style.get("width"))
+                if width:
+                    target.width = Cm(width)
                 for run in p.runs:
-                    _set_run_font(run, self.font_name, self.font_size - 1, "FFFFFF" if is_header else self.theme["text"])
+                    if is_header and not _run_has_explicit_color(run):
+                        run.font.color.rgb = RGBColor.from_string("FFFFFF")
                     if is_header:
                         run.bold = True
-                target_col += colspan
         self.doc.add_paragraph().paragraph_format.space_after = Pt(0)
 
     def _render_landscape_container(self, tag: Tag) -> None:
@@ -339,7 +366,7 @@ class _DocxRenderer:
 
     def _render_callout(self, tag: Tag, default_fill: str | None = None) -> None:
         style = self._style(tag)
-        fill = _parse_color(style.get("background-color") or style.get("background")) or default_fill or self.theme["accent"]
+        fill = _background_color(style) or default_fill or self.theme["accent"]
         border = _parse_border_color(style.get("border-left")) or self.theme["secondary"]
         before = len(self.doc.paragraphs)
         block_children = [c for c in tag.children if isinstance(c, Tag) and c.name in _BLOCK_TAGS]
@@ -370,7 +397,7 @@ class _DocxRenderer:
             alt = tag.get("alt") or "图片"
             paragraph.add_run(f"[{alt}]").italic = True
 
-    def _apply_paragraph_style(self, paragraph, tag: Tag) -> None:
+    def _apply_paragraph_style(self, paragraph, tag: Tag, *, include_box_model: bool = True) -> None:
         style = self._style(tag)
         alignment = style.get("text-align")
         if alignment in {"center", "right", "justify", "left"}:
@@ -380,9 +407,13 @@ class _DocxRenderer:
                 "justify": WD_ALIGN_PARAGRAPH.JUSTIFY,
                 "left": WD_ALIGN_PARAGRAPH.LEFT,
             }[alignment]
-        fill = _parse_color(style.get("background-color") or style.get("background"))
-        if fill:
-            _set_paragraph_shading(paragraph, fill)
+        if include_box_model:
+            fill = _background_color(style)
+            if fill:
+                _set_paragraph_shading(paragraph, fill)
+        _apply_paragraph_metrics(paragraph, style, include_box_model=include_box_model)
+        if include_box_model:
+            _apply_paragraph_borders(paragraph, style)
 
     def _apply_run_style(self, run, tag: Tag) -> None:
         style = self._style(tag)
@@ -399,10 +430,27 @@ class _DocxRenderer:
             run.underline = True
         if tag.name in {"s", "del"} or "line-through" in decoration:
             run.font.strike = True
+        if tag.name == "mark":
+            _set_run_shading(run, _background_color(style) or "FFF2CC")
+        if tag.name == "sup":
+            run.font.superscript = True
+        if tag.name == "sub":
+            run.font.subscript = True
+        spacing = _css_length_to_twips(style.get("letter-spacing"))
+        if spacing is not None:
+            _set_run_spacing(run, spacing)
         if tag.name == "code":
             run.font.name = "Cascadia Mono"
             _set_run_shading(run, "F2F2F2")
 
+    def _append_text(self, paragraph, text: str, tag: Tag | None = None) -> None:
+        for value, color in _word_safe_fragments(text):
+            run = paragraph.add_run(value)
+            if tag is not None:
+                self._apply_run_style(run, tag)
+            if color is not None:
+                run.font.color.rgb = RGBColor.from_string(color)
+
     def _style(self, tag: Tag) -> dict[str, str]:
         inherited: dict[str, str] = {}
         if isinstance(tag.parent, Tag):
@@ -413,7 +461,11 @@ class _DocxRenderer:
     def _is_callout(self, tag: Tag) -> bool:
         classes = set(tag.get("class", []))
         style = self._style(tag)
-        return bool(classes & {"info-box", "highlight", "warning", "callout", "notice"}) or "border-left" in style
+        callout_classes = {
+            "info-box", "info-block", "highlight", "warning", "warning-block",
+            "callout", "notice", "executive-summary", "summary-box",
+        }
+        return bool(classes & callout_classes) or "border-left" in style
 
 
 _BLOCK_TAGS = {"p", "div", "section", "article", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "table", "blockquote", "pre", "hr"}
@@ -490,6 +542,112 @@ def _parse_declarations(raw: str) -> dict[str, str]:
     return declarations
 
 
+def _background_color(style: dict[str, str]) -> str | None:
+    """Return a Word-compatible solid fallback for CSS backgrounds."""
+    for key in ("background-color", "background", "background-image"):
+        color = _parse_color(style.get(key))
+        if color:
+            return color
+    return None
+
+
+def _apply_paragraph_metrics(paragraph, style: dict[str, str], *, include_box_model: bool = True) -> None:
+    if include_box_model:
+        before = _css_length_to_points(_box_side(style, "margin", "top"))
+        after = _css_length_to_points(_box_side(style, "margin", "bottom"))
+        padding_top = _css_length_to_points(_box_side(style, "padding", "top")) or 0
+        padding_bottom = _css_length_to_points(_box_side(style, "padding", "bottom")) or 0
+        if before is not None or padding_top:
+            paragraph.paragraph_format.space_before = Pt((before or 0) + padding_top)
+        if after is not None or padding_bottom:
+            paragraph.paragraph_format.space_after = Pt((after or 0) + padding_bottom)
+
+        left = _css_length_to_cm(_box_side(style, "margin", "left")) or 0
+        right = _css_length_to_cm(_box_side(style, "margin", "right")) or 0
+        left += _css_length_to_cm(_box_side(style, "padding", "left")) or 0
+        right += _css_length_to_cm(_box_side(style, "padding", "right")) or 0
+        if left:
+            paragraph.paragraph_format.left_indent = Cm(left)
+        if right:
+            paragraph.paragraph_format.right_indent = Cm(right)
+        indent = _css_length_to_cm(style.get("text-indent"))
+        if indent is not None:
+            paragraph.paragraph_format.first_line_indent = Cm(indent)
+
+    line_height = style.get("line-height", "").strip().lower()
+    if line_height:
+        match = re.fullmatch(r"([0-9.]+)\s*(%|pt|px)?", line_height)
+        if match:
+            amount = float(match.group(1))
+            unit = match.group(2)
+            if unit == "%":
+                paragraph.paragraph_format.line_spacing = amount / 100
+            elif unit in {"pt", "px"}:
+                paragraph.paragraph_format.line_spacing = Pt(amount if unit == "pt" else amount * 0.75)
+            else:
+                paragraph.paragraph_format.line_spacing = amount
+    if style.get("page-break-inside") == "avoid" or style.get("break-inside") == "avoid":
+        paragraph.paragraph_format.keep_together = True
+    if style.get("page-break-after") == "avoid" or style.get("break-after") == "avoid":
+        paragraph.paragraph_format.keep_with_next = True
+
+
+def _apply_paragraph_borders(paragraph, style: dict[str, str]) -> None:
+    for side in ("top", "left", "bottom", "right"):
+        raw = style.get(f"border-{side}") or style.get("border")
+        color = _parse_border_color(raw)
+        if color and not _border_is_none(raw):
+            _set_paragraph_border(paragraph, color, side=side, size=_border_size(raw))
+
+
+def _apply_container_box(paragraphs: list, style: dict[str, str]) -> None:
+    if not paragraphs:
+        return
+    left = _css_length_to_cm(_box_side(style, "padding", "left")) or 0
+    right = _css_length_to_cm(_box_side(style, "padding", "right")) or 0
+    for paragraph in paragraphs:
+        if left:
+            paragraph.paragraph_format.left_indent = Cm(left)
+        if right:
+            paragraph.paragraph_format.right_indent = Cm(right)
+        for side in ("left", "right"):
+            raw = style.get(f"border-{side}") or style.get("border")
+            color = _parse_border_color(raw)
+            if color and not _border_is_none(raw):
+                _set_paragraph_border(paragraph, color, side=side, size=_border_size(raw))
+    first, last = paragraphs[0], paragraphs[-1]
+    top = _css_length_to_points(_box_side(style, "padding", "top"))
+    bottom = _css_length_to_points(_box_side(style, "padding", "bottom"))
+    if top:
+        first.paragraph_format.space_before = Pt(top)
+    if bottom:
+        last.paragraph_format.space_after = Pt(bottom)
+    for paragraph, side in ((first, "top"), (last, "bottom")):
+        raw = style.get(f"border-{side}") or style.get("border")
+        color = _parse_border_color(raw)
+        if color and not _border_is_none(raw):
+            _set_paragraph_border(paragraph, color, side=side, size=_border_size(raw))
+
+
+def _border_size(value: str | None) -> str:
+    points = _css_length_to_points(value)
+    return str(max(2, min(round((points or 1) * 8), 96)))
+
+
+def _border_is_none(value: str | None) -> bool:
+    return not value or any(token in value.lower().split() for token in ("none", "hidden", "0"))
+
+
+def _table_column_widths(tag: Tag, col_count: int) -> list[float | None]:
+    widths: list[float | None] = []
+    colgroup = tag.find("colgroup", recursive=False)
+    if colgroup is not None:
+        for col in colgroup.find_all("col", recursive=False):
+            style = _parse_declarations(col.get("style", ""))
+            widths.append(_css_length_to_cm(style.get("width") or col.get("width")))
+    return (widths + [None] * col_count)[:col_count]
+
+
 def _parse_color(value: str | None) -> str | None:
     if not value:
         return None
@@ -512,38 +670,6 @@ def _parse_border_color(value: str | None) -> str | None:
     return _parse_color(value)
 
 
-def _css_font_size(value: str | None, default: int) -> float:
-    if not value:
-        return default
-    match = re.search(r"([0-9.]+)\s*(pt|px|em|rem)?", value)
-    if not match:
-        return default
-    amount = float(match.group(1))
-    unit = match.group(2) or "pt"
-    if unit == "px":
-        amount *= 0.75
-    elif unit in {"em", "rem"}:
-        amount *= default
-    return max(6, min(amount, 72))
-
-
-def _css_length_to_cm(value: str | None) -> float | None:
-    if not value:
-        return None
-    match = re.search(r"([0-9.]+)\s*(cm|mm|in|pt|px|%)?", str(value))
-    if not match:
-        return None
-    amount = float(match.group(1))
-    unit = match.group(2) or "px"
-    return {"cm": amount, "mm": amount / 10, "in": amount * 2.54, "pt": amount * 2.54 / 72, "px": amount * 2.54 / 96, "%": 15.5 * amount / 100}[unit]
-
-
-def _first_font(value: str | None) -> str | None:
-    if not value:
-        return None
-    return value.split(",", 1)[0].strip().strip("\"'")
-
-
 def _set_style_font(style, name: str, size: float, color: str) -> None:
     style.font.name = name
     style.font.size = Pt(size)
@@ -559,6 +685,20 @@ def _set_run_font(run, name: str, size: float, color: str | None = None) -> None
         run.font.color.rgb = RGBColor.from_string(color)
 
 
+def _set_run_spacing(run, twips: int) -> None:
+    r_pr = run._r.get_or_add_rPr()
+    spacing = r_pr.find(qn("w:spacing"))
+    if spacing is None:
+        spacing = OxmlElement("w:spacing")
+        r_pr.append(spacing)
+    spacing.set(qn("w:val"), str(twips))
+
+
+def _run_has_explicit_color(run) -> bool:
+    r_pr = run._r.rPr
+    return r_pr is not None and r_pr.find(qn("w:color")) is not None
+
+
 def _style_all_runs(paragraph, name: str, size: float, color: str) -> None:
     for run in paragraph.runs:
         _set_run_font(run, name, size, color)
@@ -589,12 +729,14 @@ def _set_paragraph_border(paragraph, color: str, *, side: str, size: str = "8")
         p_pr.append(borders)
     sides = ["top", "left", "bottom", "right"] if side == "all" else [side]
     for side_name in sides:
-        edge = OxmlElement(f"w:{side_name}")
+        edge = borders.find(qn(f"w:{side_name}"))
+        if edge is None:
+            edge = OxmlElement(f"w:{side_name}")
+            borders.append(edge)
         edge.set(qn("w:val"), "single")
         edge.set(qn("w:sz"), size)
         edge.set(qn("w:space"), "4")
         edge.set(qn("w:color"), color)
-        borders.append(edge)
 
 
 def _set_cell_shading(cell, color: str) -> None:
@@ -609,9 +751,64 @@ def _set_cell_shading(cell, color: str) -> None:
 
 def _set_cell_vertical_alignment(cell, value: str) -> None:
     tc_pr = cell._tc.get_or_add_tcPr()
-    align = OxmlElement("w:vAlign")
+    align = tc_pr.find(qn("w:vAlign"))
+    if align is None:
+        align = OxmlElement("w:vAlign")
+        tc_pr.append(align)
     align.set(qn("w:val"), value)
-    tc_pr.append(align)
+
+
+def _set_cell_margins(cell, style: dict[str, str]) -> None:
+    tc_pr = cell._tc.get_or_add_tcPr()
+    margins = tc_pr.find(qn("w:tcMar"))
+    if margins is None:
+        margins = OxmlElement("w:tcMar")
+        tc_pr.append(margins)
+    defaults = {"top": 80, "left": 100, "bottom": 80, "right": 100}
+    for side, default in defaults.items():
+        value = _css_length_to_twips(_box_side(style, "padding", side))
+        node = margins.find(qn(f"w:{side}"))
+        if node is None:
+            node = OxmlElement(f"w:{side}")
+            margins.append(node)
+        node.set(qn("w:w"), str(value if value is not None else default))
+        node.set(qn("w:type"), "dxa")
+
+
+def _set_cell_borders(cell, style: dict[str, str], default_color: str) -> None:
+    if not any(key == "border" or key.startswith("border-") for key in style):
+        return
+    tc_pr = cell._tc.get_or_add_tcPr()
+    borders = tc_pr.find(qn("w:tcBorders"))
+    if borders is None:
+        borders = OxmlElement("w:tcBorders")
+        tc_pr.append(borders)
+    for side in ("top", "left", "bottom", "right"):
+        raw = style.get(f"border-{side}") or style.get("border")
+        node = borders.find(qn(f"w:{side}"))
+        if node is None:
+            node = OxmlElement(f"w:{side}")
+            borders.append(node)
+        if _border_is_none(raw):
+            node.set(qn("w:val"), "nil")
+            continue
+        node.set(qn("w:val"), "single")
+        node.set(qn("w:sz"), _border_size(raw))
+        node.set(qn("w:color"), _parse_border_color(raw) or default_color)
+
+
+def _prevent_table_row_split(row) -> None:
+    tr_pr = row._tr.get_or_add_trPr()
+    if tr_pr.find(qn("w:cantSplit")) is None:
+        tr_pr.append(OxmlElement("w:cantSplit"))
+
+
+def _repeat_table_header(row) -> None:
+    tr_pr = row._tr.get_or_add_trPr()
+    if tr_pr.find(qn("w:tblHeader")) is None:
+        marker = OxmlElement("w:tblHeader")
+        marker.set(qn("w:val"), "true")
+        tr_pr.append(marker)
 
 
 def _add_hyperlink(paragraph, text: str, url: str, color: str) -> None: