anymous 1.3.0 → 1.3.2

package/skills/pptx/scripts/clean.py

@@ -1,309 +0,0 @@
-"""Remove unreferenced files from an unpacked PPTX directory.
-
-Usage: python clean.py <unpacked_dir>
-
-Example:
-    python clean.py unpacked/
-
-This script removes:
-- Orphaned slides (not in sldIdLst) and their relationships
-- [trash] directory (unreferenced files)
-- Orphaned .rels files for deleted resources
-- Unreferenced media, embeddings, charts, diagrams, drawings, ink files
-- Unreferenced theme files
-- Unreferenced notes slides
-- Content-Type overrides for deleted files
-"""
-
-import posixpath
-import re
-import sys
-from pathlib import Path
-
-import defusedxml.minidom
-
-from office.helpers import SLIDE_REL_TYPE, opc_target, rels_source_part
-
-
-def _slide_rids(pres_rels_path: Path, unpacked_dir: Path) -> dict[str, str]:
-    source_part = rels_source_part(pres_rels_path, unpacked_dir)
-    rels_dom = defusedxml.minidom.parse(str(pres_rels_path))
-
-    rids: dict[str, str] = {}
-    for rel in rels_dom.getElementsByTagName("Relationship"):
-        if rel.getAttribute("Type") != SLIDE_REL_TYPE:
-            continue
-        part = opc_target(
-            rel.getAttribute("Target"), source_part, rel.getAttribute("TargetMode")
-        )
-        if part is not None:
-            rids[rel.getAttribute("Id")] = part
-    return rids
-
-
-def get_slides_in_sldidlst(unpacked_dir: Path) -> set[str]:
-    pres_path = unpacked_dir / "ppt" / "presentation.xml"
-    pres_rels_path = unpacked_dir / "ppt" / "_rels" / "presentation.xml.rels"
-
-    if not pres_path.exists() or not pres_rels_path.exists():
-        return set()
-
-    rid_to_slide = _slide_rids(pres_rels_path, unpacked_dir)
-
-    pres_content = pres_path.read_text(encoding="utf-8")
-    referenced_rids = set(re.findall(r'<p:sldId[^>]*r:id="([^"]+)"', pres_content))
-
-    return {
-        posixpath.basename(rid_to_slide[rid])
-        for rid in referenced_rids
-        if rid in rid_to_slide
-    }
-
-
-class RefusedToClean(Exception):
-    """The package does not look the way a readable package should."""
-
-
-def remove_orphaned_slides(unpacked_dir: Path) -> list[str]:
-    slides_dir = unpacked_dir / "ppt" / "slides"
-    slides_rels_dir = slides_dir / "_rels"
-    pres_rels_path = unpacked_dir / "ppt" / "_rels" / "presentation.xml.rels"
-
-    if not slides_dir.exists():
-        return []
-
-    referenced_slides = get_slides_in_sldidlst(unpacked_dir)
-    on_disk = sorted(slides_dir.glob("slide*.xml"))
-
-    if on_disk and not any(s.name in referenced_slides for s in on_disk):
-        listed = re.findall(
-            r'<p:sldId[^>]*r:id="([^"]+)"',
-            (unpacked_dir / "ppt" / "presentation.xml").read_text(encoding="utf-8")
-            if (unpacked_dir / "ppt" / "presentation.xml").exists()
-            else "",
-        )
-        if listed:
-            raise RefusedToClean(
-                f"<p:sldIdLst> lists {len(listed)} slide(s) and none of the "
-                f"{len(on_disk)} slide(s) on disk match any of them. Refusing to "
-                f"delete them all — this is a parse failure, not an empty deck."
-            )
-
-    removed = []
-
-    for slide_file in on_disk:
-        if slide_file.name not in referenced_slides:
-            rel_path = slide_file.relative_to(unpacked_dir)
-            slide_file.unlink()
-            removed.append(str(rel_path))
-
-            rels_file = slides_rels_dir / f"{slide_file.name}.rels"
-            if rels_file.exists():
-                rels_file.unlink()
-                removed.append(str(rels_file.relative_to(unpacked_dir)))
-
-    if removed and pres_rels_path.exists():
-        rels_dom = defusedxml.minidom.parse(str(pres_rels_path))
-        source_part = rels_source_part(pres_rels_path, unpacked_dir)
-        changed = False
-
-        for rel in list(rels_dom.getElementsByTagName("Relationship")):
-            if rel.getAttribute("Type") != SLIDE_REL_TYPE:
-                continue
-            part = opc_target(
-                rel.getAttribute("Target"), source_part, rel.getAttribute("TargetMode")
-            )
-            if part is None:
-                continue
-            if posixpath.basename(part) not in referenced_slides:
-                if rel.parentNode:
-                    rel.parentNode.removeChild(rel)
-                    changed = True
-
-        if changed:
-            with open(pres_rels_path, "wb") as f:
-                f.write(rels_dom.toxml(encoding="utf-8"))
-
-    return removed
-
-
-def remove_trash_directory(unpacked_dir: Path) -> list[str]:
-    trash_dir = unpacked_dir / "[trash]"
-    removed = []
-
-    if trash_dir.exists() and trash_dir.is_dir():
-        for file_path in trash_dir.iterdir():
-            if file_path.is_file():
-                rel_path = file_path.relative_to(unpacked_dir)
-                removed.append(str(rel_path))
-                file_path.unlink()
-        trash_dir.rmdir()
-
-    return removed
-
-
-def _referenced_by(rels_files, unpacked_dir: Path) -> set:
-    referenced = set()
-
-    for rels_file in rels_files:
-        source_part = rels_source_part(rels_file, unpacked_dir)
-        dom = defusedxml.minidom.parse(str(rels_file))
-        for rel in dom.getElementsByTagName("Relationship"):
-            part = opc_target(
-                rel.getAttribute("Target"), source_part, rel.getAttribute("TargetMode")
-            )
-            if part is not None:
-                referenced.add(Path(part))
-
-    return referenced
-
-
-def remove_orphaned_rels_files(unpacked_dir: Path) -> list[str]:
-    resource_dirs = ["charts", "diagrams", "drawings"]
-    removed = []
-
-    for dir_name in resource_dirs:
-        rels_dir = unpacked_dir / "ppt" / dir_name / "_rels"
-        if not rels_dir.exists():
-            continue
-
-        for rels_file in rels_dir.glob("*.rels"):
-            resource_file = rels_dir.parent / rels_file.name.replace(".rels", "")
-            if not resource_file.exists():
-                rels_file.unlink()
-                removed.append(str(rels_file.relative_to(unpacked_dir)))
-
-    return removed
-
-
-def get_referenced_files(unpacked_dir: Path) -> set:
-    return _referenced_by(sorted(unpacked_dir.rglob("*.rels")), unpacked_dir)
-
-
-def remove_orphaned_files(unpacked_dir: Path, referenced: set) -> list[str]:
-    resource_dirs = ["media", "embeddings", "charts", "diagrams", "tags", "drawings", "ink"]
-    removed = []
-
-    for dir_name in resource_dirs:
-        dir_path = unpacked_dir / "ppt" / dir_name
-        if not dir_path.exists():
-            continue
-
-        for file_path in dir_path.glob("*"):
-            if not file_path.is_file():
-                continue
-            rel_path = file_path.relative_to(unpacked_dir)
-            if rel_path not in referenced:
-                file_path.unlink()
-                removed.append(str(rel_path))
-
-    theme_dir = unpacked_dir / "ppt" / "theme"
-    if theme_dir.exists():
-        for file_path in theme_dir.glob("theme*.xml"):
-            rel_path = file_path.relative_to(unpacked_dir)
-            if rel_path not in referenced:
-                file_path.unlink()
-                removed.append(str(rel_path))
-                theme_rels = theme_dir / "_rels" / f"{file_path.name}.rels"
-                if theme_rels.exists():
-                    theme_rels.unlink()
-                    removed.append(str(theme_rels.relative_to(unpacked_dir)))
-
-    notes_dir = unpacked_dir / "ppt" / "notesSlides"
-    if notes_dir.exists():
-        for file_path in notes_dir.glob("*.xml"):
-            if not file_path.is_file():
-                continue
-            rel_path = file_path.relative_to(unpacked_dir)
-            if rel_path not in referenced:
-                file_path.unlink()
-                removed.append(str(rel_path))
-
-        notes_rels_dir = notes_dir / "_rels"
-        if notes_rels_dir.exists():
-            for file_path in notes_rels_dir.glob("*.rels"):
-                notes_file = notes_dir / file_path.name.replace(".rels", "")
-                if not notes_file.exists():
-                    file_path.unlink()
-                    removed.append(str(file_path.relative_to(unpacked_dir)))
-
-    return removed
-
-
-def update_content_types(unpacked_dir: Path, removed_files: list[str]) -> None:
-    ct_path = unpacked_dir / "[Content_Types].xml"
-    if not ct_path.exists():
-        return
-
-    dom = defusedxml.minidom.parse(str(ct_path))
-    changed = False
-
-    for override in list(dom.getElementsByTagName("Override")):
-        part_name = override.getAttribute("PartName").lstrip("/")
-        if part_name in removed_files:
-            if override.parentNode:
-                override.parentNode.removeChild(override)
-                changed = True
-
-    if changed:
-        with open(ct_path, "wb") as f:
-            f.write(dom.toxml(encoding="utf-8"))
-
-
-def clean_unused_files(unpacked_dir: Path) -> list[str]:
-    all_removed = []
-
-    if list(unpacked_dir.rglob("*.rels")) and not get_referenced_files(unpacked_dir):
-        raise RefusedToClean(
-            "no relationship in this package names a part we can resolve. "
-            "Refusing to treat every file as unreferenced."
-        )
-
-    slides_removed = remove_orphaned_slides(unpacked_dir)
-    all_removed.extend(slides_removed)
-
-    trash_removed = remove_trash_directory(unpacked_dir)
-    all_removed.extend(trash_removed)
-
-    while True:
-        removed_rels = remove_orphaned_rels_files(unpacked_dir)
-        referenced = get_referenced_files(unpacked_dir)
-        removed_files = remove_orphaned_files(unpacked_dir, referenced)
-
-        total_removed = removed_rels + removed_files
-        if not total_removed:
-            break
-
-        all_removed.extend(total_removed)
-
-    if all_removed:
-        update_content_types(unpacked_dir, all_removed)
-
-    return all_removed
-
-
-if __name__ == "__main__":
-    if len(sys.argv) != 2:
-        print("Usage: python clean.py <unpacked_dir>", file=sys.stderr)
-        print("Example: python clean.py unpacked/", file=sys.stderr)
-        sys.exit(1)
-
-    unpacked_dir = Path(sys.argv[1])
-
-    if not unpacked_dir.exists():
-        print(f"Error: {unpacked_dir} not found", file=sys.stderr)
-        sys.exit(1)
-
-    try:
-        removed = clean_unused_files(unpacked_dir)
-    except (RefusedToClean, ValueError) as e:
-        print(f"Error: {e}", file=sys.stderr)
-        print("Nothing was deleted.", file=sys.stderr)
-        sys.exit(1)
-
-    if removed:
-        print(f"Removed {len(removed)} unreferenced files:")
-        for f in removed:
-            print(f"  {f}")
-    else:
-        print("No unreferenced files found")

package/skills/pptx/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/pptx/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/pptx/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