@_vrsen/openswarm 0.1.0

package/docs_agent/tools/utils/html_docx_playwright.py

@@ -0,0 +1,184 @@
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+from bs4 import BeautifulSoup
+from playwright.sync_api import sync_playwright
+import subprocess
+from .html_docx_page import _extract_page_geometry_pt
+
+_PT_TO_PX = 96.0 / 72.0
+
+# Elements that must never be split across a page boundary.
+_UNSPLITTABLE_SELECTORS = "table, img, figure, blockquote, pre, svg"
+
+# CSS applied to the inserted page-break div.
+_PB_STYLE = "page-break-before:always;break-before:page;margin:0;padding:0;height:0;"
+
+# Block-level tags whose children can directly receive a page-break sibling.
+_BLOCK_PARENTS = frozenset(["BODY", "DIV", "TD", "TH", "SECTION", "ARTICLE", "MAIN"])
+
+
+def auto_page_breaks(html_content: str) -> str:
+    """Insert page-break divs before unsplittable elements that cross a page boundary.
+
+    Renders the HTML in a single Playwright session at A4 width, identifies every
+    table / img / figure / blockquote / pre / svg whose bounding box crosses a page
+    boundary, and inserts a zero-height page-break-before div directly before it in
+    the live DOM.  The modified HTML is returned via page.content().
+
+    No thresholds — if the element crosses any boundary, it moves to the next page.
+    """
+    with tempfile.NamedTemporaryFile(
+        suffix=".html", delete=False, mode="w", encoding="utf-8"
+    ) as fh:
+        fh.write(html_content)
+        tmp_path = Path(fh.name)
+
+    try:
+        with sync_playwright() as playwright:
+            browser = _launch_chromium_with_install(playwright)
+            viewport_width_px, page_height_px = _extract_page_geometry_px(html_content)
+            page = browser.new_page(
+                viewport={"width": viewport_width_px, "height": page_height_px * 20}
+            )
+            page.emulate_media(media="print")
+            page.route(
+                "**/*",
+                lambda route, request: route.abort()
+                if request.resource_type in {"media", "font"}
+                else route.continue_(),
+            )
+            page.goto(tmp_path.as_uri(), wait_until="load")
+
+            block_parents_js = str(list(_BLOCK_PARENTS))
+            page.evaluate(
+                f"""([selectors, pageH, pbStyle]) => {{
+                    const BLOCK_PARENTS = new Set({block_parents_js});
+                    const processed = new WeakSet();
+
+                    for (const el of document.querySelectorAll(selectors)) {{
+                        const rect = el.getBoundingClientRect();
+                        if (rect.height <= 0) continue;
+
+                        // Mark tables that fit within one page — the DOCX converter will
+                        // apply w:cantSplit to their rows so Word keeps them together.
+                        if (el.tagName === 'TABLE' && rect.height < pageH) {{
+                            el.setAttribute('data-docx-cant-split', '1');
+                        }}
+
+                        // Inject page-break before unsplittable elements that cross a boundary.
+                        if (rect.height >= pageH) continue;
+                        const topPage = Math.floor(rect.top / pageH);
+                        const botPage = Math.floor((rect.bottom - 1) / pageH);
+                        if (topPage === botPage) continue;
+
+                        let node = el;
+                        while (node.parentElement && !BLOCK_PARENTS.has(node.parentElement.tagName))
+                            node = node.parentElement;
+
+                        if (!node.parentElement) continue;
+                        if (processed.has(node)) continue;
+                        processed.add(node);
+
+                        const pb = document.createElement('div');
+                        pb.setAttribute('style', pbStyle);
+                        node.parentElement.insertBefore(pb, node);
+                    }}
+                }}""",
+                [_UNSPLITTABLE_SELECTORS, page_height_px, _PB_STYLE],
+            )
+
+            modified_html = page.content()
+            browser.close()
+    finally:
+        tmp_path.unlink(missing_ok=True)
+
+    return modified_html
+
+
+def _extract_page_geometry_px(html_content: str) -> tuple[int, int]:
+    width_pt, height_pt, top_pt, _right_pt, bottom_pt, _left_pt = _extract_page_geometry_pt(
+        html_content
+    )
+    viewport_width_px = max(1, round(width_pt * _PT_TO_PX))
+    content_height_pt = max(1.0, height_pt - top_pt - bottom_pt)
+    page_height_px = max(1, round(content_height_pt * _PT_TO_PX))
+    return viewport_width_px, page_height_px
+
+
+def _annotate_tables(soup: BeautifulSoup) -> str:
+    tables = soup.find_all("table")
+    for idx, table in enumerate(tables):
+        table["data-docx-table-idx"] = str(idx)
+    return str(soup)
+
+
+def _compute_table_auto_widths(html_content: str) -> dict[int, list[float]]:
+    widths_by_index: dict[int, list[float]] = {}
+    with sync_playwright() as playwright:
+        browser = _launch_chromium_with_install(playwright)
+        page = browser.new_page(viewport={"width": 1200, "height": 1600})
+        page.route(
+            "**/*",
+            lambda route, request: route.abort()
+            if request.resource_type in {"image", "media", "font"}
+            else route.continue_(),
+        )
+        page.set_content(html_content, wait_until="domcontentloaded")
+        tables = page.query_selector_all("table[data-docx-table-idx]")
+        for table in tables:
+            idx_value = table.get_attribute("data-docx-table-idx")
+            if idx_value is None:
+                continue
+            rows = table.query_selector_all("tr")
+            if not rows:
+                continue
+            row = rows[0]
+            cells = row.query_selector_all(":scope > td, :scope > th")
+            if not cells:
+                continue
+            widths_px = []
+            for cell in cells:
+                box = cell.bounding_box()
+                if box:
+                    widths_px.append(box["width"])
+            if widths_px:
+                widths_by_index[int(idx_value)] = [width * 0.75 for width in widths_px]
+        browser.close()
+    return widths_by_index
+
+
+def _extract_auto_widths(
+    table_node, table_auto_widths: dict[int, list[float]], column_count: int
+) -> Optional[list[float]]:
+    idx_value = table_node.get("data-docx-table-idx")
+    if idx_value is None:
+        return None
+    try:
+        idx = int(idx_value)
+    except ValueError:
+        return None
+    widths = table_auto_widths.get(idx)
+    if not widths or len(widths) < column_count:
+        return None
+    return widths[:column_count]
+
+
+def _launch_chromium_with_install(playwright_instance):
+    try:
+        return playwright_instance.chromium.launch()
+    except Exception as exc:
+        if _is_missing_playwright_browser_error(exc):
+            _install_playwright_chromium()
+            return playwright_instance.chromium.launch()
+        raise
+
+
+def _is_missing_playwright_browser_error(exc: Exception) -> bool:
+    message = str(exc)
+    return "Executable doesn't exist" in message or "playwright install" in message
+
+
+def _install_playwright_chromium() -> None:
+    subprocess.run(["playwright", "install", "chromium"], check=True)

package/docs_agent/tools/utils/html_docx_selectors.py

@@ -0,0 +1,196 @@
+from typing import Dict, List, Optional, Tuple
+
+from bs4 import BeautifulSoup
+from bs4.element import Tag
+import tinycss2
+
+
+def _parse_style(style: str) -> Dict[str, str]:
+    items = {}
+    for rule in style.split(";"):
+        if ":" not in rule:
+            continue
+        key, value = rule.split(":", 1)
+        key = key.strip().lower()
+        value = value.strip()
+        if key and value:
+            items[key] = value
+    return items
+
+
+def _extract_css_rules(
+    soup: BeautifulSoup,
+) -> List[Tuple[str, Dict[str, str], Tuple[int, int, int], int]]:
+    rules: List[Tuple[str, Dict[str, str], Tuple[int, int, int], int]] = []
+    order = 0
+
+    for style_tag in soup.find_all("style"):
+        css_text = style_tag.string or style_tag.get_text()
+        if not css_text:
+            continue
+
+        stylesheet = tinycss2.parse_stylesheet(
+            css_text, skip_comments=True, skip_whitespace=True
+        )
+        for rule in stylesheet:
+            if rule.type != "qualified-rule":
+                continue
+
+            selectors_text = tinycss2.serialize(rule.prelude).strip()
+            if not selectors_text:
+                continue
+
+            declarations = tinycss2.parse_declaration_list(
+                rule.content, skip_comments=True, skip_whitespace=True
+            )
+            style_map: Dict[str, str] = {}
+            for declaration in declarations:
+                if declaration.type != "declaration":
+                    continue
+                name = declaration.name.lower().strip() if declaration.name else ""
+                value = tinycss2.serialize(declaration.value).strip()
+                if name and value:
+                    style_map[name] = value
+
+            for selector in [s.strip() for s in selectors_text.split(",") if s.strip()]:
+                pseudo = None
+                if "::before" in selector:
+                    pseudo = "before"
+                    base_selector = selector.replace("::before", "").strip()
+                elif "::after" in selector:
+                    pseudo = "after"
+                    base_selector = selector.replace("::after", "").strip()
+                else:
+                    base_selector = selector
+
+                if not _is_supported_selector(base_selector):
+                    continue
+
+                rule_styles = style_map
+                if pseudo:
+                    rule_styles = {f"pseudo-{pseudo}-{k}": v for k, v in style_map.items()}
+
+                specificity = _selector_specificity(base_selector)
+                rules.append((base_selector, rule_styles, specificity, order))
+                order += 1
+
+    return rules
+
+
+def _compute_style_map(
+    element, css_rules: List[Tuple[str, Dict[str, str], Tuple[int, int, int], int]]
+) -> Dict[str, str]:
+    resolved: Dict[str, str] = {}
+    matches: List[Tuple[Tuple[int, int, int], int, Dict[str, str]]] = []
+
+    for selector, styles, specificity, order in css_rules:
+        if _matches_selector(element, selector):
+            matches.append((specificity, order, styles))
+
+    matches.sort(key=lambda item: (item[0], item[1]))
+    for _, __, styles in matches:
+        resolved.update(styles)
+
+    inline_styles = _parse_style(element.get("style", ""))
+    resolved.update(inline_styles)
+
+    return resolved
+
+
+def _is_supported_selector(selector: str) -> bool:
+    selector = selector.strip()
+    if not selector:
+        return False
+    if any(token in selector for token in ["#", "[", "]", "*", "+", "~"]):
+        return False
+    return True
+
+
+def _selector_specificity(selector: str) -> Tuple[int, int, int]:
+    selectors = _parse_selector_chain(selector)
+    class_count = sum(len(classes) for _, classes in selectors)
+    tag_count = sum(1 for tag, _ in selectors if tag)
+    return (0, class_count, tag_count)
+
+
+def _parse_selector(selector: str) -> Tuple[Optional[str], List[str]]:
+    selector = selector.strip()
+    if selector.startswith("."):
+        tag = None
+        classes = [cls for cls in selector[1:].split(".") if cls]
+    else:
+        parts = [part for part in selector.split(".") if part]
+        tag = parts[0] if parts else None
+        classes = parts[1:] if len(parts) > 1 else []
+    return tag, classes
+
+
+def _matches_selector(element, selector: str) -> bool:
+    chain = _parse_selector_chain(selector)
+    if not chain:
+        return False
+    return _matches_selector_chain(element, chain)
+
+
+def _parse_selector_chain(selector: str) -> List[Tuple[Optional[str], List[str]]]:
+    tokens = selector.replace(">", " > ").split()
+    if not tokens:
+        return []
+    selectors: List[Tuple[Optional[str], List[str]]] = []
+    for token in tokens:
+        if token == ">":
+            selectors.append((">", []))
+        else:
+            selectors.append(_parse_selector(token))
+    return selectors
+
+
+def _matches_selector_chain(element: Tag, chain: List[Tuple[Optional[str], List[str]]]) -> bool:
+    idx = len(chain) - 1
+    current = element
+
+    while idx >= 0:
+        token = chain[idx]
+        if token[0] == ">":
+            idx -= 1
+            if idx < 0:
+                return False
+            parent_selector = chain[idx]
+            current = current.parent if isinstance(current.parent, Tag) else None
+            if current is None or not _matches_simple_selector(current, parent_selector):
+                return False
+            idx -= 1
+            continue
+
+        if not _matches_simple_selector(current, token):
+            return False
+
+        idx -= 1
+        if idx >= 0 and chain[idx][0] != ">":
+            ancestor_selector = chain[idx]
+            matched = False
+            ancestor = current.parent
+            while isinstance(ancestor, Tag):
+                if _matches_simple_selector(ancestor, ancestor_selector):
+                    matched = True
+                    current = ancestor
+                    break
+                ancestor = ancestor.parent
+            if not matched:
+                return False
+            idx -= 1
+
+    return True
+
+
+def _matches_simple_selector(
+    element: Tag, selector: Tuple[Optional[str], List[str]]
+) -> bool:
+    tag, classes = selector
+    if tag and element.name != tag:
+        return False
+    if classes:
+        element_classes = set(element.get("class", []))
+        if not all(cls in element_classes for cls in classes):
+            return False
+    return True

package/docs_agent/tools/utils/html_docx_shared.py

@@ -0,0 +1,23 @@
+def _remove_trailing_empty_paragraph(container) -> None:
+    if not hasattr(container, "paragraphs"):
+        return
+    if not container.paragraphs:
+        return
+    last = container.paragraphs[-1]
+    if last.text.strip():
+        return
+    # Preserve empty paragraphs that carry a visual border (used as divider lines).
+    if "<w:pBdr>" in last._p.xml:
+        return
+    last._element.getparent().remove(last._element)
+
+
+def _remove_leading_empty_paragraph(container) -> None:
+    if not hasattr(container, "paragraphs"):
+        return
+    if not container.paragraphs:
+        return
+    first = container.paragraphs[0]
+    if first.text.strip():
+        return
+    first._element.getparent().remove(first._element)