@heylemon/lemonade 0.1.4 → 0.1.6

package/skills/pptx/scripts/clean.py

@@ -1,286 +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 sys
-from pathlib import Path
-
-import defusedxml.minidom
-
-
-import re
-
-
-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()
-
-    rels_dom = defusedxml.minidom.parse(str(pres_rels_path))
-    rid_to_slide = {}
-    for rel in rels_dom.getElementsByTagName("Relationship"):
-        rid = rel.getAttribute("Id")
-        target = rel.getAttribute("Target")
-        rel_type = rel.getAttribute("Type")
-        if "slide" in rel_type and target.startswith("slides/"):
-            rid_to_slide[rid] = target.replace("slides/", "")
-
-    pres_content = pres_path.read_text(encoding="utf-8")
-    referenced_rids = set(re.findall(r'<p:sldId[^>]*r:id="([^"]+)"', pres_content))
-
-    return {rid_to_slide[rid] for rid in referenced_rids if rid in rid_to_slide}
-
-
-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)
-    removed = []
-
-    for slide_file in slides_dir.glob("slide*.xml"):
-        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))
-        changed = False
-
-        for rel in list(rels_dom.getElementsByTagName("Relationship")):
-            target = rel.getAttribute("Target")
-            if target.startswith("slides/"):
-                slide_name = target.replace("slides/", "")
-                if slide_name 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 get_slide_referenced_files(unpacked_dir: Path) -> set:
-    referenced = set()
-    slides_rels_dir = unpacked_dir / "ppt" / "slides" / "_rels"
-
-    if not slides_rels_dir.exists():
-        return referenced
-
-    for rels_file in slides_rels_dir.glob("*.rels"):
-        dom = defusedxml.minidom.parse(str(rels_file))
-        for rel in dom.getElementsByTagName("Relationship"):
-            target = rel.getAttribute("Target")
-            if not target:
-                continue
-            target_path = (rels_file.parent.parent / target).resolve()
-            try:
-                referenced.add(target_path.relative_to(unpacked_dir.resolve()))
-            except ValueError:
-                pass
-
-    return referenced
-
-
-def remove_orphaned_rels_files(unpacked_dir: Path) -> list[str]:
-    resource_dirs = ["charts", "diagrams", "drawings"]
-    removed = []
-    slide_referenced = get_slide_referenced_files(unpacked_dir)
-
-    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", "")
-            try:
-                resource_rel_path = resource_file.resolve().relative_to(unpacked_dir.resolve())
-            except ValueError:
-                continue
-
-            if not resource_file.exists() or resource_rel_path not in slide_referenced:
-                rels_file.unlink()
-                rel_path = rels_file.relative_to(unpacked_dir)
-                removed.append(str(rel_path))
-
-    return removed
-
-
-def get_referenced_files(unpacked_dir: Path) -> set:
-    referenced = set()
-
-    for rels_file in unpacked_dir.rglob("*.rels"):
-        dom = defusedxml.minidom.parse(str(rels_file))
-        for rel in dom.getElementsByTagName("Relationship"):
-            target = rel.getAttribute("Target")
-            if not target:
-                continue
-            target_path = (rels_file.parent.parent / target).resolve()
-            try:
-                referenced.add(target_path.relative_to(unpacked_dir.resolve()))
-            except ValueError:
-                pass
-
-    return referenced
-
-
-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 = []
-
-    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)
-
-    removed = clean_unused_files(unpacked_dir)
-
-    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/thumbnail.py

@@ -1,289 +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 subprocess
-import sys
-import tempfile
-import zipfile
-from pathlib import Path
-
-import defusedxml.minidom
-from office.soffice import get_soffice_env
-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 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_slide = {}
-        for rel in rels_dom.getElementsByTagName("Relationship"):
-            rid = rel.getAttribute("Id")
-            target = rel.getAttribute("Target")
-            rel_type = rel.getAttribute("Type")
-            if "slide" in rel_type and target.startswith("slides/"):
-                rid_to_slide[rid] = target.replace("slides/", "")
-
-        pres_content = zf.read("ppt/presentation.xml").decode("utf-8")
-        pres_dom = defusedxml.minidom.parseString(pres_content)
-
-        slides = []
-        for sld_id in pres_dom.getElementsByTagName("p:sldId"):
-            rid = sld_id.getAttribute("r:id")
-            if rid in rid_to_slide:
-                hidden = sld_id.getAttribute("show") == "0"
-                slides.append({"name": rid_to_slide[rid], "hidden": hidden})
-
-        return slides
-
-
-def build_slide_list(
-    slide_info: list[dict],
-    visible_images: list[Path],
-    temp_dir: Path,
-) -> list[tuple[Path, str]]:
-    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"]:
-            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:
-            if visible_idx < len(visible_images):
-                slides.append((visible_images[visible_idx], info["name"]))
-                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 = subprocess.run(
-        [
-            "soffice",
-            "--headless",
-            "--convert-to",
-            "pdf",
-            "--outdir",
-            str(temp_dir),
-            str(pptx_path),
-        ],
-        capture_output=True,
-        text=True,
-        env=get_soffice_env(),
-    )
-    if result.returncode != 0 or not pdf_path.exists():
-        raise RuntimeError("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()