anymous 1.3.0 → 1.3.2

package/skills/pptx/scripts/office/validators/redlining.py

@@ -1,299 +0,0 @@
-"""
-Validator for tracked changes in Word documents.
-
-Detects untracked edits in word/document.xml: text that differs from the
-original without a <w:ins>/<w:del> wrapper recording it. The tracked changes
-that are new relative to the original are undone, and the result is compared
-against the original; whatever text still differs was edited without being
-tracked.
-
-Only the document body is compared. Headers, footers, footnotes and endnotes
-are separate parts and are not checked.
-"""
-
-import subprocess
-import tempfile
-import zipfile
-from pathlib import Path
-
-import defusedxml.ElementTree as ET
-from defusedxml.common import DefusedXmlException
-
-from helpers import rendered_text, safe_extract
-
-
-class RedliningValidator:
-
-    def __init__(self, unpacked_dir, original_docx, verbose=False):
-        self.unpacked_dir = Path(unpacked_dir)
-        self.original_docx = Path(original_docx)
-        self.verbose = verbose
-        self.namespaces = {
-            "w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
-        }
-
-    def repair(self) -> int:
-        return 0
-
-    def validate(self):
-        modified_file = self.unpacked_dir / "word" / "document.xml"
-        if not modified_file.exists():
-            print(f"FAILED - Modified document.xml not found at {modified_file}")
-            return False
-
-        with tempfile.TemporaryDirectory() as temp_dir:
-            temp_path = Path(temp_dir)
-
-            try:
-                with zipfile.ZipFile(self.original_docx, "r") as zip_ref:
-                    safe_extract(zip_ref, temp_path)
-            except Exception as e:
-                print(f"FAILED - Error unpacking original docx: {e}")
-                return False
-
-            original_file = temp_path / "word" / "document.xml"
-            if not original_file.exists():
-                print(
-                    f"FAILED - Original document.xml not found in {self.original_docx}"
-                )
-                return False
-
-            try:
-                modified_tree = ET.parse(modified_file)
-                modified_root = modified_tree.getroot()
-                original_tree = ET.parse(original_file)
-                original_root = original_tree.getroot()
-            except (ET.ParseError, DefusedXmlException) as e:
-                print(f"FAILED - Error parsing XML files: {e}")
-                return False
-
-            new_changes = self._new_tracked_changes(original_root, modified_root)
-            self._remove_tracked_changes(modified_root, new_changes)
-
-            modified_text = self._extract_text_content(modified_root)
-            original_text = self._extract_text_content(original_root)
-
-            if modified_text != original_text:
-                error_message = self._generate_detailed_diff(
-                    original_text, modified_text
-                )
-                print(error_message)
-                return False
-
-            if self.verbose:
-                print(
-                    f"PASSED - All {len(new_changes)} change(s) against the original "
-                    "are properly tracked"
-                )
-            return True
-
-    def _tracked_change_elements(self, root):
-        ins_tag = f"{{{self.namespaces['w']}}}ins"
-        del_tag = f"{{{self.namespaces['w']}}}del"
-        return [elem for elem in root.iter() if elem.tag in (ins_tag, del_tag)]
-
-    def _rendered_text(self, elem):
-        preserve = elem.get("{http://www.w3.org/XML/1998/namespace}space") == "preserve"
-        return rendered_text(elem.text or "", preserve)
-
-    def _text_elements(self, elem):
-        w = self.namespaces["w"]
-        return [
-            node
-            for node in elem.iter()
-            if node.tag in (f"{{{w}}}t", f"{{{w}}}delText")
-        ]
-
-    def _tracked_change_key(self, elem):
-        w = self.namespaces["w"]
-        text = "".join(self._rendered_text(node) for node in self._text_elements(elem))
-        return (elem.tag, elem.get(f"{{{w}}}author"), elem.get(f"{{{w}}}date"), text)
-
-    def _new_tracked_changes(self, original_root, modified_root):
-        original = self._tracked_change_elements(original_root)
-        modified = self._tracked_change_elements(modified_root)
-
-        pool = {}
-        for elem in original:
-            pool.setdefault(self._tracked_change_key(elem), []).append(elem)
-
-        matched, leftover = set(), []
-        for elem in modified:
-            bucket = pool.get(self._tracked_change_key(elem))
-            if bucket:
-                matched.add(bucket.pop())
-            else:
-                leftover.append(elem)
-
-        def group(elem):
-            return self._tracked_change_key(elem)[:3]
-
-        def text_of(elems):
-            return "".join(self._tracked_change_key(e)[3] for e in elems)
-
-        unmatched_original = {}
-        for elem in original:
-            if elem not in matched:
-                unmatched_original.setdefault(group(elem), []).append(elem)
-
-        by_group = {}
-        for elem in leftover:
-            by_group.setdefault(group(elem), []).append(elem)
-
-        new = set()
-        for key, elems in by_group.items():
-            rebuilt = text_of(elems)
-            if rebuilt and rebuilt == text_of(unmatched_original.get(key, [])):
-                continue  
-            new.update(elems)
-        return new
-
-    def _generate_detailed_diff(self, original_text, modified_text):
-        error_parts = [
-            "FAILED - Document text doesn't match after removing the tracked changes",
-            "",
-            "Likely causes:",
-            "  1. Modified text inside another author's <w:ins> or <w:del> tags",
-            "  2. Made edits without proper tracked changes",
-            "  3. Didn't nest <w:del> inside <w:ins> when deleting another's insertion",
-            "  4. Rewrote another author's <w:ins>/<w:del> and changed its text on",
-            "     the way. A tracked change from the original is recognised by its",
-            "     author, date and text; anything that doesn't reproduce one exactly",
-            "     reads as new, and the text it carried is reported missing.",
-            "",
-            "For pre-redlined documents, use correct patterns:",
-            "  - To reject another's INSERTION: Nest <w:del> inside their <w:ins>",
-            "  - To reject PART of one: nest <w:del> around only the runs you reject.",
-            "    Their <w:ins> may be split around it, so long as the pieces keep",
-            "    their author and date and still spell out the same text.",
-            "  - To restore another's DELETION: Add new <w:ins> AFTER their <w:del>",
-            "",
-        ]
-
-        git_diff = self._get_git_word_diff(original_text, modified_text)
-        if git_diff:
-            error_parts.extend(["Differences:", "============", git_diff])
-        else:
-            error_parts.append("Unable to generate word diff (git not available)")
-
-        return "\n".join(error_parts)
-
-    def _get_git_word_diff(self, original_text, modified_text):
-        try:
-            with tempfile.TemporaryDirectory() as temp_dir:
-                temp_path = Path(temp_dir)
-
-                original_file = temp_path / "original.txt"
-                modified_file = temp_path / "modified.txt"
-
-                original_file.write_text(original_text, encoding="utf-8")
-                modified_file.write_text(modified_text, encoding="utf-8")
-
-                result = subprocess.run(
-                    [
-                        "git",
-                        "diff",
-                        "--word-diff=plain",
-                        "--word-diff-regex=.",  
-                        "-U0",  
-                        "--no-index",
-                        str(original_file),
-                        str(modified_file),
-                    ],
-                    capture_output=True,
-                    text=True,
-                )
-
-                if result.stdout.strip():
-                    lines = result.stdout.split("\n")
-                    content_lines = []
-                    in_content = False
-                    for line in lines:
-                        if line.startswith("@@"):
-                            in_content = True
-                            continue
-                        if in_content and line.strip():
-                            content_lines.append(line)
-
-                    if content_lines:
-                        return "\n".join(content_lines)
-
-                result = subprocess.run(
-                    [
-                        "git",
-                        "diff",
-                        "--word-diff=plain",
-                        "-U0",  
-                        "--no-index",
-                        str(original_file),
-                        str(modified_file),
-                    ],
-                    capture_output=True,
-                    text=True,
-                )
-
-                if result.stdout.strip():
-                    lines = result.stdout.split("\n")
-                    content_lines = []
-                    in_content = False
-                    for line in lines:
-                        if line.startswith("@@"):
-                            in_content = True
-                            continue
-                        if in_content and line.strip():
-                            content_lines.append(line)
-                    return "\n".join(content_lines)
-
-        except (subprocess.CalledProcessError, FileNotFoundError, Exception):
-            pass
-
-        return None
-
-    def _remove_tracked_changes(self, root, targets):
-        ins_tag = f"{{{self.namespaces['w']}}}ins"
-        del_tag = f"{{{self.namespaces['w']}}}del"
-
-        for parent in root.iter():
-            to_remove = []
-            for child in parent:
-                if child.tag == ins_tag and child in targets:
-                    to_remove.append(child)
-            for elem in to_remove:
-                parent.remove(elem)
-
-        deltext_tag = f"{{{self.namespaces['w']}}}delText"
-        t_tag = f"{{{self.namespaces['w']}}}t"
-
-        for parent in root.iter():
-            to_process = []
-            for child in parent:
-                if child.tag == del_tag and child in targets:
-                    to_process.append((child, list(parent).index(child)))
-
-            for del_elem, del_index in reversed(to_process):
-                for elem in del_elem.iter():
-                    if elem.tag == deltext_tag:
-                        elem.tag = t_tag
-
-                for child in reversed(list(del_elem)):
-                    parent.insert(del_index, child)
-                parent.remove(del_elem)
-
-    def _extract_text_content(self, root):
-        p_tag = f"{{{self.namespaces['w']}}}p"
-        t_tag = f"{{{self.namespaces['w']}}}t"
-
-        paragraphs = []
-        for p_elem in root.findall(f".//{p_tag}"):
-            text_parts = []
-            for t_elem in p_elem.findall(f".//{t_tag}"):
-                text_parts.append(self._rendered_text(t_elem))
-            paragraph_text = "".join(text_parts)
-            if paragraph_text:
-                paragraphs.append(paragraph_text)
-
-        return "\n".join(paragraphs)
-
-
-if __name__ == "__main__":
-    raise RuntimeError("This module should not be run directly.")

package/skills/pptx/scripts/thumbnail.py

@@ -1,311 +0,0 @@
-"""Create thumbnail grids from PowerPoint presentation slides.
-
-Creates a grid layout of slide thumbnails for quick visual analysis.
-Labels each thumbnail with its XML filename (e.g., slide1.xml).
-Hidden slides are shown with a placeholder pattern.
-
-Usage:
-    python thumbnail.py input.pptx [output_prefix] [--cols N]
-
-Examples:
-    python thumbnail.py presentation.pptx
-    # Creates: thumbnails.jpg
-
-    python thumbnail.py template.pptx grid --cols 4
-    # Creates: grid.jpg (or grid-1.jpg, grid-2.jpg for large decks)
-"""
-
-import argparse
-import posixpath
-import subprocess
-import sys
-import tempfile
-import zipfile
-from pathlib import Path
-
-import defusedxml.minidom
-from defusedxml import ElementTree
-from office.helpers import SLIDE_REL_TYPE, opc_target
-from office.soffice import run_soffice
-from PIL import Image, ImageDraw, ImageFont
-
-
-THUMBNAIL_WIDTH = 300
-CONVERSION_DPI = 100
-MAX_COLS = 6
-DEFAULT_COLS = 3
-JPEG_QUALITY = 95
-GRID_PADDING = 20
-BORDER_WIDTH = 2
-FONT_SIZE_RATIO = 0.10
-LABEL_PADDING_RATIO = 0.4
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Create thumbnail grids from PowerPoint slides."
-    )
-    parser.add_argument("input", help="Input PowerPoint file (.pptx)")
-    parser.add_argument(
-        "output_prefix",
-        nargs="?",
-        default="thumbnails",
-        help="Output prefix for image files (default: thumbnails)",
-    )
-    parser.add_argument(
-        "--cols",
-        type=int,
-        default=DEFAULT_COLS,
-        help=f"Number of columns (default: {DEFAULT_COLS}, max: {MAX_COLS})",
-    )
-
-    args = parser.parse_args()
-
-    cols = min(args.cols, MAX_COLS)
-    if args.cols > MAX_COLS:
-        print(f"Warning: Columns limited to {MAX_COLS}")
-
-    input_path = Path(args.input)
-    if not input_path.exists() or input_path.suffix.lower() != ".pptx":
-        print(f"Error: Invalid PowerPoint file: {args.input}", file=sys.stderr)
-        sys.exit(1)
-
-    output_path = Path(f"{args.output_prefix}.jpg")
-
-    try:
-        slide_info = get_slide_info(input_path)
-
-        with tempfile.TemporaryDirectory() as temp_dir:
-            temp_path = Path(temp_dir)
-            visible_images = convert_to_images(input_path, temp_path)
-
-            if not visible_images and not any(s["hidden"] for s in slide_info):
-                print("Error: No slides found", file=sys.stderr)
-                sys.exit(1)
-
-            slides = build_slide_list(slide_info, visible_images, temp_path)
-
-            grid_files = create_grids(slides, cols, THUMBNAIL_WIDTH, output_path)
-
-            print(f"Created {len(grid_files)} grid(s):")
-            for grid_file in grid_files:
-                print(f"  {grid_file}")
-
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-def _is_hidden(zf: zipfile.ZipFile, part: str) -> bool:
-    try:
-        with zf.open(part) as f:
-            for _, root in ElementTree.iterparse(f, events=("start",)):
-                return root.get("show") in ("0", "false")  
-    except (KeyError, ElementTree.ParseError):
-        return False
-    return False
-
-
-def get_slide_info(pptx_path: Path) -> list[dict]:
-    with zipfile.ZipFile(pptx_path, "r") as zf:
-        rels_content = zf.read("ppt/_rels/presentation.xml.rels").decode("utf-8")
-        rels_dom = defusedxml.minidom.parseString(rels_content)
-
-        rid_to_part = {}
-        for rel in rels_dom.getElementsByTagName("Relationship"):
-            if rel.getAttribute("Type") != SLIDE_REL_TYPE:
-                continue
-            part = opc_target(
-                rel.getAttribute("Target"),
-                "ppt/presentation.xml",
-                rel.getAttribute("TargetMode"),
-            )
-            if part is not None:
-                rid_to_part[rel.getAttribute("Id")] = part
-
-        pres_content = zf.read("ppt/presentation.xml").decode("utf-8")
-        pres_dom = defusedxml.minidom.parseString(pres_content)
-
-        present = set(zf.namelist())
-
-        slides = []
-        for sld_id in pres_dom.getElementsByTagName("p:sldId"):
-            part = rid_to_part.get(sld_id.getAttribute("r:id"))
-            if part is not None and part in present:
-                slides.append(
-                    {"name": posixpath.basename(part), "hidden": _is_hidden(zf, part)}
-                )
-
-        return slides
-
-
-def build_slide_list(
-    slide_info: list[dict],
-    visible_images: list[Path],
-    temp_dir: Path,
-) -> list[tuple[Path, str]]:
-    visible_count = sum(1 for info in slide_info if not info["hidden"])
-    rendered_hidden = len(visible_images) == len(slide_info) != visible_count
-
-    if not rendered_hidden and visible_count != len(visible_images):
-        raise ValueError(
-            f"LibreOffice rendered {len(visible_images)} page(s) for {visible_count} "
-            f"visible slide(s) of {len(slide_info)}; thumbnails would be mislabeled"
-        )
-
-    if visible_images:
-        with Image.open(visible_images[0]) as img:
-            placeholder_size = img.size
-    else:
-        placeholder_size = (1920, 1080)
-
-    slides = []
-    visible_idx = 0
-
-    for info in slide_info:
-        if info["hidden"] and not rendered_hidden:
-            placeholder_path = temp_dir / f"hidden-{info['name']}.jpg"
-            placeholder_img = create_hidden_placeholder(placeholder_size)
-            placeholder_img.save(placeholder_path, "JPEG")
-            slides.append((placeholder_path, f"{info['name']} (hidden)"))
-        else:
-            label = f"{info['name']} (hidden)" if info["hidden"] else info["name"]
-            slides.append((visible_images[visible_idx], label))
-            visible_idx += 1
-
-    return slides
-
-
-def create_hidden_placeholder(size: tuple[int, int]) -> Image.Image:
-    img = Image.new("RGB", size, color="#F0F0F0")
-    draw = ImageDraw.Draw(img)
-    line_width = max(5, min(size) // 100)
-    draw.line([(0, 0), size], fill="#CCCCCC", width=line_width)
-    draw.line([(size[0], 0), (0, size[1])], fill="#CCCCCC", width=line_width)
-    return img
-
-
-def convert_to_images(pptx_path: Path, temp_dir: Path) -> list[Path]:
-    pdf_path = temp_dir / f"{pptx_path.stem}.pdf"
-
-    result = run_soffice(
-        ["--headless", "--convert-to", "pdf", "--outdir", str(temp_dir), str(pptx_path)],
-        capture_output=True,
-        text=True,
-    )
-    if result.returncode != 0 or not pdf_path.exists():
-        detail = (result.stderr or result.stdout or "").strip()
-        raise RuntimeError(f"PDF conversion failed: {detail}" if detail else "PDF conversion failed")
-
-    result = subprocess.run(
-        [
-            "pdftoppm",
-            "-jpeg",
-            "-r",
-            str(CONVERSION_DPI),
-            str(pdf_path),
-            str(temp_dir / "slide"),
-        ],
-        capture_output=True,
-        text=True,
-    )
-    if result.returncode != 0:
-        raise RuntimeError("Image conversion failed")
-
-    return sorted(temp_dir.glob("slide-*.jpg"))
-
-
-def create_grids(
-    slides: list[tuple[Path, str]],
-    cols: int,
-    width: int,
-    output_path: Path,
-) -> list[str]:
-    max_per_grid = cols * (cols + 1)
-    grid_files = []
-
-    for chunk_idx, start_idx in enumerate(range(0, len(slides), max_per_grid)):
-        end_idx = min(start_idx + max_per_grid, len(slides))
-        chunk_slides = slides[start_idx:end_idx]
-
-        grid = create_grid(chunk_slides, cols, width)
-
-        if len(slides) <= max_per_grid:
-            grid_filename = output_path
-        else:
-            stem = output_path.stem
-            suffix = output_path.suffix
-            grid_filename = output_path.parent / f"{stem}-{chunk_idx + 1}{suffix}"
-
-        grid_filename.parent.mkdir(parents=True, exist_ok=True)
-        grid.save(str(grid_filename), quality=JPEG_QUALITY)
-        grid_files.append(str(grid_filename))
-
-    return grid_files
-
-
-def create_grid(
-    slides: list[tuple[Path, str]],
-    cols: int,
-    width: int,
-) -> Image.Image:
-    font_size = int(width * FONT_SIZE_RATIO)
-    label_padding = int(font_size * LABEL_PADDING_RATIO)
-
-    with Image.open(slides[0][0]) as img:
-        aspect = img.height / img.width
-    height = int(width * aspect)
-
-    rows = (len(slides) + cols - 1) // cols
-    grid_w = cols * width + (cols + 1) * GRID_PADDING
-    grid_h = rows * (height + font_size + label_padding * 2) + (rows + 1) * GRID_PADDING
-
-    grid = Image.new("RGB", (grid_w, grid_h), "white")
-    draw = ImageDraw.Draw(grid)
-
-    try:
-        font = ImageFont.load_default(size=font_size)
-    except Exception:
-        font = ImageFont.load_default()
-
-    for i, (img_path, slide_name) in enumerate(slides):
-        row, col = i // cols, i % cols
-        x = col * width + (col + 1) * GRID_PADDING
-        y_base = (
-            row * (height + font_size + label_padding * 2) + (row + 1) * GRID_PADDING
-        )
-
-        label = slide_name
-        bbox = draw.textbbox((0, 0), label, font=font)
-        text_w = bbox[2] - bbox[0]
-        draw.text(
-            (x + (width - text_w) // 2, y_base + label_padding),
-            label,
-            fill="black",
-            font=font,
-        )
-
-        y_thumbnail = y_base + label_padding + font_size + label_padding
-
-        with Image.open(img_path) as img:
-            img.thumbnail((width, height), Image.Resampling.LANCZOS)
-            w, h = img.size
-            tx = x + (width - w) // 2
-            ty = y_thumbnail + (height - h) // 2
-            grid.paste(img, (tx, ty))
-
-            if BORDER_WIDTH > 0:
-                draw.rectangle(
-                    [
-                        (tx - BORDER_WIDTH, ty - BORDER_WIDTH),
-                        (tx + w + BORDER_WIDTH - 1, ty + h + BORDER_WIDTH - 1),
-                    ],
-                    outline="gray",
-                    width=BORDER_WIDTH,
-                )
-
-    return grid
-
-
-if __name__ == "__main__":
-    main()