@preapexis/piexis 0.1.2

package/skills/docx/scripts/merge_runs.py

@@ -0,0 +1,310 @@
+"""Merge adjacent identically-formatted runs in a DOCX.
+
+Word fragments paragraph text across many <w:r> elements (revision ids,
+spell-check markers, editing history), which makes find-and-replace on
+word/document.xml unreliable — the string you're looking for is split
+across runs. This coalesces adjacent runs whose formatting (<w:rPr>) is
+identical, strips rsid attributes and proofErr markers, and consolidates the
+text elements — <w:t>, and <w:delText> for text inside a tracked deletion.
+
+Rendering is unchanged. The text you search is what Word draws, which is not
+always the bytes in the file: an element without xml:space="preserve" has its
+edge whitespace trimmed before it reaches the page, so `<w:t>Hello </w:t>`
+followed by `<w:t>world</w:t>` reads "Helloworld" and merges to exactly that.
+
+Runs in two different <w:ins>/<w:del> wrappers are never merged: that would
+rewrite tracked-change structure, collapsing separate revisions into one.
+
+Only word/document.xml is processed (not headers, footers, or footnotes).
+
+Usage:
+    python merge_runs.py unpacked/                  # after unzip, before editing
+    python merge_runs.py document.docx              # rewrite in place
+    python merge_runs.py document.docx -o out.docx
+"""
+
+
+import argparse
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+
+import defusedxml.minidom
+
+from office.helpers import XML_SPACE, rendered_text, rezip, safe_extract
+
+WORDML_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+
+
+def merge_runs(input_dir: str) -> tuple[int, str]:
+    doc_xml = Path(input_dir) / "word" / "document.xml"
+
+    if not doc_xml.exists():
+        return 0, f"Error: {doc_xml} not found"
+
+    try:
+        dom = defusedxml.minidom.parseString(doc_xml.read_text(encoding="utf-8"))
+        root = dom.documentElement
+        run_names = _run_tag_names(root)
+
+        _remove_elements(root, "proofErr")
+
+        runs = _find_runs(root, run_names)
+        _strip_rsid_attrs(runs)
+
+        merge_count = 0
+        for container in {run.parentNode for run in runs}:
+            merge_count += _merge_runs_in(container, run_names)
+
+        doc_xml.write_bytes(dom.toxml(encoding="UTF-8"))
+        return merge_count, f"Merged {merge_count} runs"
+
+    except Exception as e:
+        return 0, f"Error: {e}"
+
+
+
+
+def _is_element(node, tag: str) -> bool:
+    name = node.localName or node.tagName
+    return name == tag or name.endswith(f":{tag}")
+
+
+def _run_tag_names(root) -> set[str]:
+    names = set()
+    for attr in root.attributes.values():
+        if attr.value == WORDML_NS:
+            if attr.name == "xmlns":
+                names.add("r")
+            elif attr.name.startswith("xmlns:"):
+                names.add(attr.name.split(":", 1)[1] + ":r")
+    return names or {"w:r", "r"}
+
+
+def _find_elements(root, tag: str) -> list:
+    results = []
+
+    def traverse(node):
+        if node.nodeType == node.ELEMENT_NODE:
+            if _is_element(node, tag):
+                results.append(node)
+            for child in node.childNodes:
+                traverse(child)
+
+    traverse(root)
+    return results
+
+
+def _find_runs(root, run_names: set[str]) -> list:
+    return [e for e in _find_elements(root, "r") if _is_run(e, run_names)]
+
+
+def _get_child(parent, tag: str):
+    return next(iter(_get_children(parent, tag)), None)
+
+
+def _get_children(parent, tag: str) -> list:
+    return [
+        child
+        for child in parent.childNodes
+        if child.nodeType == child.ELEMENT_NODE and _is_element(child, tag)
+    ]
+
+
+def _is_adjacent(elem1, elem2) -> bool:
+    node = elem1.nextSibling
+    while node:
+        if node == elem2:
+            return True
+        if node.nodeType == node.ELEMENT_NODE:
+            return False
+        if node.nodeType == node.TEXT_NODE and node.data.strip(XML_SPACE):
+            return False
+        node = node.nextSibling
+    return False
+
+
+
+
+def _remove_elements(root, tag: str):
+    for elem in _find_elements(root, tag):
+        if elem.parentNode:
+            elem.parentNode.removeChild(elem)
+
+
+def _strip_rsid_attrs(runs: list):
+    for run in runs:
+        for attr in list(run.attributes.values()):
+            if "rsid" in attr.name.lower():
+                run.removeAttribute(attr.name)
+
+
+
+
+def _merge_runs_in(container, run_names: set[str]) -> int:
+    merge_count = 0
+    run = _first_child_run(container, run_names)
+
+    while run:
+        while True:
+            next_elem = _next_element_sibling(run)
+            if next_elem and _is_run(next_elem, run_names) and _can_merge(run, next_elem):
+                _merge_run_content(run, next_elem)
+                container.removeChild(next_elem)
+                merge_count += 1
+            else:
+                break
+
+        _consolidate_text(run)
+        run = _next_sibling_run(run, run_names)
+
+    return merge_count
+
+
+def _first_child_run(container, run_names: set[str]):
+    for child in container.childNodes:
+        if child.nodeType == child.ELEMENT_NODE and _is_run(child, run_names):
+            return child
+    return None
+
+
+def _next_element_sibling(node):
+    sibling = node.nextSibling
+    while sibling:
+        if sibling.nodeType == sibling.ELEMENT_NODE:
+            return sibling
+        sibling = sibling.nextSibling
+    return None
+
+
+def _next_sibling_run(node, run_names: set[str]):
+    sibling = node.nextSibling
+    while sibling:
+        if sibling.nodeType == sibling.ELEMENT_NODE:
+            if _is_run(sibling, run_names):
+                return sibling
+        sibling = sibling.nextSibling
+    return None
+
+
+def _is_run(node, run_names: set[str]) -> bool:
+    return node.tagName in run_names
+
+
+def _can_merge(run1, run2) -> bool:
+    rpr1 = _get_child(run1, "rPr")
+    rpr2 = _get_child(run2, "rPr")
+
+    if (rpr1 is None) != (rpr2 is None):
+        return False
+    if rpr1 is None:
+        return True
+    return rpr1.toxml() == rpr2.toxml()  
+
+
+def _merge_run_content(target, source):
+    for child in list(source.childNodes):
+        if child.nodeType == child.ELEMENT_NODE:
+            name = child.localName or child.tagName
+            if name != "rPr" and not name.endswith(":rPr"):
+                target.appendChild(child)
+
+
+def _element_text(elem) -> str:
+    return "".join(
+        child.data
+        for child in elem.childNodes
+        if child.nodeType in (child.TEXT_NODE, child.CDATA_SECTION_NODE)
+    )
+
+
+def _has_preserve(elem) -> bool:
+    return elem.getAttribute("xml:space") == "preserve"
+
+
+def _rendered_text(elem) -> str:
+    return rendered_text(_element_text(elem), _has_preserve(elem))
+
+
+def _consolidate_text(run):
+    for tag in ("t", "delText"):
+        _consolidate_text_elements(run, tag)
+
+
+def _consolidate_text_elements(run, tag: str):
+    t_elements = _get_children(run, tag)
+
+    for i in range(len(t_elements) - 1, 0, -1):
+        curr, prev = t_elements[i], t_elements[i - 1]
+
+        if _is_adjacent(prev, curr):
+            merged = _rendered_text(prev) + _rendered_text(curr)
+            had_preserve = _has_preserve(prev) or _has_preserve(curr)
+
+            new_text = run.ownerDocument.createTextNode(merged)
+            for node in list(prev.childNodes):
+                if node.nodeType in (node.TEXT_NODE, node.CDATA_SECTION_NODE):
+                    prev.removeChild(node)
+                else:
+                    run.insertBefore(node, curr)
+            prev.appendChild(new_text)
+            for node in list(curr.childNodes):
+                if node.nodeType not in (node.TEXT_NODE, node.CDATA_SECTION_NODE):
+                    run.insertBefore(node, curr)
+
+            if merged != merged.strip(XML_SPACE) or had_preserve:
+                prev.setAttribute("xml:space", "preserve")
+            elif prev.hasAttribute("xml:space"):
+                prev.removeAttribute("xml:space")
+
+            run.removeChild(curr)
+
+
+
+
+def _merge_or_die(path: Path) -> str:
+    _, msg = merge_runs(str(path))
+    if msg.startswith("Error"):
+        print(msg, file=sys.stderr)
+        sys.exit(1)
+    return msg
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(
+        description="Merge adjacent identically-formatted runs in a DOCX (directory or .docx file)."
+    )
+    p.add_argument("input", help="Unpacked DOCX directory OR a .docx/.dotx file")
+    p.add_argument(
+        "-o", "--output",
+        help="Output .docx path (only valid when input is a .docx; default: overwrite input)",
+    )
+    args = p.parse_args()
+
+    src = Path(args.input)
+
+    try:
+        if src.is_dir():
+            if args.output:
+                p.error("--output is only valid for .docx input; directory input is modified in place")
+            print(_merge_or_die(src))
+        elif src.is_file() and src.suffix.lower() in (".docx", ".dotx"):
+            out = Path(args.output) if args.output else src
+            with tempfile.TemporaryDirectory() as tmp:
+                tmp_path = Path(tmp)
+                with zipfile.ZipFile(src) as zf:
+                    safe_extract(zf, tmp_path)
+                msg = _merge_or_die(tmp_path)
+                rezip(tmp_path, out)
+            print(f"{msg}; wrote {out}")
+        else:
+            print(f"Error: {src} is neither a directory nor a .docx/.dotx file", file=sys.stderr)
+            sys.exit(1)
+    except (OSError, ValueError, zipfile.BadZipFile) as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/skills/docx/scripts/office/helpers/__init__.py

@@ -0,0 +1,111 @@
+import os
+import posixpath
+import re
+import stat
+import tempfile
+import urllib.parse
+import zipfile
+from pathlib import Path
+
+OOXML_FAMILY = {
+    ".docx": "docx",
+    ".dotx": "docx",
+    ".pptx": "pptx",
+    ".potx": "pptx",
+    ".xlsx": "xlsx",
+    ".xltx": "xlsx",
+}
+
+_SCHEME_RE = re.compile(r"^[A-Za-z][A-Za-z0-9+.\-]*:")
+
+SLIDE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide"
+
+
+def opc_target(target: str, source_part: str, target_mode: str = "") -> str | None:
+    if not target:
+        return None
+    if target_mode.lower() == "external":
+        return None
+    if _SCHEME_RE.match(target):
+        return None
+
+    target = urllib.parse.unquote(target)
+
+    if "\\" in target:
+        raise ValueError(f"relationship target is not a POSIX part name: {target!r}")
+
+    if target.startswith("/"):
+        joined = target.lstrip("/")
+    else:
+        joined = posixpath.join(posixpath.dirname(source_part), target)
+
+    parts: list[str] = []
+    for segment in posixpath.normpath(joined).split("/"):
+        if segment in ("", "."):
+            continue
+        if segment == "..":
+            if not parts:
+                raise ValueError(f"relationship target escapes the package: {target!r}")
+            parts.pop()
+        else:
+            parts.append(segment)
+
+    if not parts:
+        raise ValueError(f"relationship target resolves to nothing: {target!r}")
+    return "/".join(parts)
+
+
+def rels_source_part(rels_file: Path, unpacked_dir: Path) -> str:
+    owner_dir = rels_file.parent.parent.relative_to(unpacked_dir)
+    return posixpath.join(owner_dir.as_posix(), rels_file.name[: -len(".rels")]).lstrip("./")
+
+
+def part_text(data: bytes) -> str:
+    return data.decode("utf-8", "surrogateescape")
+
+
+XML_SPACE = " \t\r\n"
+
+
+def rendered_text(text: str, preserve: bool) -> str:
+    return text if preserve else text.strip(XML_SPACE)
+
+
+def safe_extract(zf: zipfile.ZipFile, dest: Path) -> None:
+    dest = dest.resolve()
+    for m in zf.infolist():
+        if stat.S_ISLNK(m.external_attr >> 16):
+            raise ValueError(f"symlink archive entry not allowed: {m.filename!r}")
+        target = (dest / m.filename).resolve()
+        if not target.is_relative_to(dest):
+            raise ValueError(f"unsafe archive entry: {m.filename!r}")
+        zf.extract(m, dest)
+
+
+def rezip(src_dir: Path, out_path: Path) -> None:
+    files = sorted(p for p in src_dir.rglob("*") if p.is_file())
+    ct = src_dir / "[Content_Types].xml"
+    fd, tmp_name = tempfile.mkstemp(
+        prefix=out_path.name + ".", suffix=".tmp", dir=out_path.parent
+    )
+    tmp_out = Path(tmp_name)
+    try:
+        with os.fdopen(fd, "wb") as fh:
+            with zipfile.ZipFile(fh, "w", zipfile.ZIP_DEFLATED) as zf:
+                if ct.exists():
+                    zf.write(ct, ct.relative_to(src_dir), compress_type=zipfile.ZIP_STORED)
+                for f in files:
+                    if f == ct:
+                        continue
+                    zf.write(f, f.relative_to(src_dir))
+        if out_path.exists():
+            mode = out_path.stat().st_mode & 0o777
+        else:
+            umask = os.umask(0)
+            os.umask(umask)
+            mode = 0o666 & ~umask
+        os.chmod(tmp_out, mode)
+        os.replace(tmp_out, out_path)
+    finally:
+        if tmp_out.exists():
+            tmp_out.unlink()

package/skills/docx/scripts/office/helpers/pptx_chart.py

@@ -0,0 +1,170 @@
+"""Find chart XML that PowerPoint refuses but the schema accepts.
+
+Detection only: for either fault more than one repair is valid, and only the
+author knows which was meant.
+"""
+
+
+from __future__ import annotations
+
+import re
+from typing import Mapping
+
+from . import part_text
+
+
+_CHART_PART_RE = re.compile(r"ppt/charts/chart\d+\.xml")
+
+_GROUPING_RE = re.compile(r"""<c:grouping\b[^>]*?\bval=["'](\w+)["']""")
+_DLBL_POS_RE = re.compile(r"""<c:dLblPos\b[^>]*?\bval=["'](\w+)["']""")
+
+def _strip_ext_lst(text: str) -> str:
+    out, cursor = [], 0
+    for lo, hi in _ext_lst_spans(text):
+        out.append(text[cursor:lo])
+        cursor = hi
+    out.append(text[cursor:])
+    return "".join(out)
+
+_BAR_GROUP_RE = re.compile(r"<c:(bar3DChart|barChart)\b[^>]*(?<!/)>.*?</c:\1\s*>", re.DOTALL)
+
+STACKED_GROUPINGS = frozenset({"stacked", "percentStacked"})
+ILLEGAL_ON_STACKED = frozenset({"outEnd"})
+LEGAL_ON_STACKED = ("ctr", "inEnd", "inBase")
+
+
+def _check_stacked_label_positions(part: str, xml: str) -> list[str]:
+    problems: list[str] = []
+    for match in _BAR_GROUP_RE.finditer(xml):
+        block = _strip_ext_lst(match.group(0))
+        group = match.group(1)
+
+        grouping = _GROUPING_RE.search(block)
+        if grouping is None or grouping.group(1) not in STACKED_GROUPINGS:
+            continue
+
+        bad = [p for p in _DLBL_POS_RE.findall(block) if p in ILLEGAL_ON_STACKED]
+        for pos in sorted(set(bad)):
+            problems.append(
+                f'{part}: {bad.count(pos)} data label(s) use dLblPos="{pos}" on a '
+                f"{grouping.group(1)} {group}; PowerPoint allows only "
+                f"{', '.join(LEGAL_ON_STACKED)} there"
+            )
+    return problems
+
+
+
+_ANY_CHART_GROUP_RE = re.compile(r"<c:(\w+Chart)\b[^>]*(?<!/)>.*?</c:\1\s*>", re.DOTALL)
+
+_AXID_RE = re.compile(
+    r"""\s*<c:axId\b[^>]*?\bval=["'](-?\d+)["']\s*(?:/>|>\s*</c:axId\s*>)"""
+)
+
+_AXIS_DECL_RE = re.compile(
+    r"""<c:(catAx|valAx|serAx|dateAx)\b[^>]*(?<!/)>\s*<c:axId\b[^>]*?\bval=["'](-?\d+)["']"""
+)
+
+AXID_LIMIT = {
+    "barChart": 2, "lineChart": 2, "areaChart": 2, "scatterChart": 2,
+    "bubbleChart": 2, "radarChart": 2, "stockChart": 2,
+    "bar3DChart": 3, "line3DChart": 3, "area3DChart": 3,
+    "surfaceChart": 3, "surface3DChart": 3,
+}
+
+AXID_MINIMUM = {
+    "barChart": 2, "lineChart": 2, "areaChart": 2, "scatterChart": 2,
+    "bubbleChart": 2, "radarChart": 2, "stockChart": 2,
+    "bar3DChart": 2, "area3DChart": 2, "surfaceChart": 2,
+    "line3DChart": 3, "surface3DChart": 3,
+}
+
+
+def _declared_axes(xml: str) -> dict[str, list[str]]:
+    axes: dict[str, list[str]] = {}
+    for kind, axid in _AXIS_DECL_RE.findall(xml):
+        axes.setdefault(kind, []).append(axid)
+    return axes
+
+
+def _canonical_ids(axes: dict[str, list[str]], limit: int) -> list[str] | None:
+    category = axes.get("catAx", []) + axes.get("dateAx", [])
+    value = axes.get("valAx", [])
+    series = axes.get("serAx", [])
+    if len(category) != 1 or len(value) != 1 or len(series) > 1:
+        return None
+    ids = [category[0], value[0]]
+    if limit >= 3 and series:
+        ids.append(series[0])
+    return ids
+
+
+def _undeclared_axes(kind: str, block: str, axes: dict[str, list[str]]) -> list[str] | None:
+    if kind not in AXID_LIMIT:
+        return None
+    ids = _AXID_RE.findall(block)
+    declared = {i for group in axes.values() for i in group}
+    if len([i for i in ids if i in declared]) >= 2:
+        return None
+    return ids
+
+
+def _check_chart_axis_references(part: str, xml: str) -> list[str]:
+    axes = _declared_axes(xml)
+    problems: list[str] = []
+    declared = {i for group in axes.values() for i in group}
+    for match in _ANY_CHART_GROUP_RE.finditer(xml):
+        kind, block = match.group(1), match.group(0)
+        ids = _undeclared_axes(kind, block, axes)
+        if ids is None:
+            continue
+        if not ids:
+            problems.append(
+                f"{part}: <c:{kind}> declares no <c:axId> this part can resolve; a chart "
+                f"group needs {AXID_MINIMUM[kind]}, and PowerPoint discards one with fewer"
+            )
+            continue
+        dead = [i for i in ids if i not in declared]
+        canonical = _canonical_ids(axes, AXID_LIMIT[kind])
+        if canonical is not None and len(canonical) >= AXID_MINIMUM[kind]:
+            hint = f"Fix: point them at the axes this part declares ({', '.join(canonical)})"
+        else:
+            hint = ("Fix: the part declares several axes of a kind -- declare the "
+                    "secondary axes the series expects, or drop them")
+        detail = (f"of which {', '.join(dead)} name no declared axis"
+                  if dead else f"only {len(ids)} of which this part declares")
+        problems.append(
+            f"{part}: <c:{kind}> references axId {', '.join(ids)}, {detail}, "
+            f"leaving fewer than two live axes; PowerPoint discards the chart. {hint}"
+        )
+    return problems
+
+
+def _ext_lst_spans(text: str) -> list[tuple[int, int]]:
+    spans: list[tuple[int, int]] = []
+    depth = 0
+    start = 0
+    for match in re.finditer(r"<(/?)c:extLst\b[^>]*?(/?)>", text):
+        closing, self_closing = match.group(1), match.group(2)
+        if self_closing:
+            continue
+        if closing:
+            depth -= 1
+            if depth == 0:
+                spans.append((start, match.end()))
+        else:
+            if depth == 0:
+                start = match.start()
+            depth += 1
+    return spans
+
+
+CHART_CHECKS = (_check_stacked_label_positions, _check_chart_axis_references)
+
+
+def find_chart_problems(files: Mapping[str, bytes]) -> list[str]:
+    problems: list[str] = []
+    for part in sorted(n for n in files if _CHART_PART_RE.fullmatch(n)):
+        xml = part_text(files[part])
+        for check in CHART_CHECKS:
+            problems.extend(check(part, xml))
+    return problems

package/skills/docx/scripts/office/helpers/pptx_slide.py

@@ -0,0 +1,60 @@
+"""Pick the slide-XML schema errors PowerPoint refuses the file over.
+
+A denylist over lxml's messages, so an unrecognised error class is a miss rather
+than a false alarm.
+"""
+
+
+from __future__ import annotations
+
+import re
+
+SLIDE_PART_RE = re.compile(
+    r"ppt/(slides|slideLayouts|slideMasters|notesSlides|notesMasters|handoutMasters)"
+    r"/[^/]+\.xml"
+)
+
+FATAL_SLIDE_ERRORS: tuple[tuple[re.Pattern[str], str], ...] = (
+    (
+        re.compile(r"\}tableStyleId': This element is not expected"),
+        "two <a:tableStyleId> in one <a:tblPr> (the schema allows one)",
+    ),
+    (
+        re.compile(r"\}srgbClr', attribute 'val'"),
+        "a colour that is not six hex digits",
+    ),
+    (
+        re.compile(r"\}txBody': Missing child element"),
+        "a <p:txBody> with no children",
+    ),
+    (
+        re.compile(r"\}miter', attribute 'lim'"),
+        'a line join with lim="NaN"',
+    ),
+    (
+        re.compile(r"\}uLnTx': This element is not expected"),
+        "<a:uLnTx> in a position the schema forbids",
+    ),
+    (
+        re.compile(r"\}overrideClrMapping': This element is not expected"),
+        "<p:overrideClrMapping> in a position the schema forbids",
+    ),
+    (
+        re.compile(r"\}nvGrpSpPr': Missing child element"),
+        "a <p:nvGrpSpPr> with no children",
+    ),
+)
+
+
+def is_schema_verdict(error: str) -> bool:
+    return error.startswith("Element ")
+
+
+def fatal_slide_errors(errors: set[str]) -> list[str]:
+    out = []
+    for error in sorted(errors):
+        for pattern, meaning in FATAL_SLIDE_ERRORS:
+            if pattern.search(error):
+                out.append(f"{meaning}: {error}")
+                break
+    return out