@pikaa-ai/pikaa 0.3.1 → 0.3.4

package/skills/docx/scripts/merge_runs.py

@@ -1,310 +0,0 @@
-"""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

@@ -1,111 +0,0 @@
-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

@@ -1,170 +0,0 @@
-"""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

@@ -1,60 +0,0 @@
-"""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