1"""Create thumbnail grids from PowerPoint presentation slides.
2 
3Creates a grid layout of slide thumbnails for quick visual analysis.
4Labels each thumbnail with its XML filename (e.g., slide1.xml).
5Hidden slides are shown with a placeholder pattern.
6 
7Usage:
8    python thumbnail.py input.pptx [output_prefix] [--cols N]
9 
10Examples:
11    python thumbnail.py presentation.pptx
12    # Creates: thumbnails.jpg
13 
14    python thumbnail.py template.pptx grid --cols 4
15    # Creates: grid.jpg (or grid-1.jpg, grid-2.jpg for large decks)
16"""
17 
18import argparse
19import subprocess
20import sys
21import tempfile
22import zipfile
23from pathlib import Path
24 
25import defusedxml.minidom
26from office.soffice import get_soffice_env
27from PIL import Image, ImageDraw, ImageFont
28 
29THUMBNAIL_WIDTH = 300
30CONVERSION_DPI = 100
31MAX_COLS = 6
32DEFAULT_COLS = 3
33JPEG_QUALITY = 95
34GRID_PADDING = 20
35BORDER_WIDTH = 2
36FONT_SIZE_RATIO = 0.10
37LABEL_PADDING_RATIO = 0.4
38 
39 
40def main():
41    parser = argparse.ArgumentParser(
42        description="Create thumbnail grids from PowerPoint slides."
43    )
44    parser.add_argument("input", help="Input PowerPoint file (.pptx)")
45    parser.add_argument(
46        "output_prefix",
47        nargs="?",
48        default="thumbnails",
49        help="Output prefix for image files (default: thumbnails)",
50    )
51    parser.add_argument(
52        "--cols",
53        type=int,
54        default=DEFAULT_COLS,
55        help=f"Number of columns (default: {DEFAULT_COLS}, max: {MAX_COLS})",
56    )
57 
58    args = parser.parse_args()
59 
60    cols = min(args.cols, MAX_COLS)
61    if args.cols > MAX_COLS:
62        print(f"Warning: Columns limited to {MAX_COLS}")
63 
64    input_path = Path(args.input)
65    if not input_path.exists() or input_path.suffix.lower() != ".pptx":
66        print(f"Error: Invalid PowerPoint file: {args.input}", file=sys.stderr)
67        sys.exit(1)
68 
69    output_path = Path(f"{args.output_prefix}.jpg")
70 
71    try:
72        slide_info = get_slide_info(input_path)
73 
74        with tempfile.TemporaryDirectory() as temp_dir:
75            temp_path = Path(temp_dir)
76            visible_images = convert_to_images(input_path, temp_path)
77 
78            if not visible_images and not any(s["hidden"] for s in slide_info):
79                print("Error: No slides found", file=sys.stderr)
80                sys.exit(1)
81 
82            slides = build_slide_list(slide_info, visible_images, temp_path)
83 
84            grid_files = create_grids(slides, cols, THUMBNAIL_WIDTH, output_path)
85 
86            print(f"Created {len(grid_files)} grid(s):")
87            for grid_file in grid_files:
88                print(f"  {grid_file}")
89 
90    except Exception as e:
91        print(f"Error: {e}", file=sys.stderr)
92        sys.exit(1)
93 
94 
95def get_slide_info(pptx_path: Path) -> list[dict]:
96    with zipfile.ZipFile(pptx_path, "r") as zf:
97        rels_content = zf.read("ppt/_rels/presentation.xml.rels").decode("utf-8")
98        rels_dom = defusedxml.minidom.parseString(rels_content)
99 
100        rid_to_slide = {}
101        for rel in rels_dom.getElementsByTagName("Relationship"):
102            rid = rel.getAttribute("Id")
103            target = rel.getAttribute("Target")
104            rel_type = rel.getAttribute("Type")
105            if "slide" in rel_type and target.startswith("slides/"):
106                rid_to_slide[rid] = target.replace("slides/", "")
107 
108        pres_content = zf.read("ppt/presentation.xml").decode("utf-8")
109        pres_dom = defusedxml.minidom.parseString(pres_content)
110 
111        slides = []
112        for sld_id in pres_dom.getElementsByTagName("p:sldId"):
113            rid = sld_id.getAttribute("r:id")
114            if rid in rid_to_slide:
115                hidden = sld_id.getAttribute("show") == "0"
116                slides.append({"name": rid_to_slide[rid], "hidden": hidden})
117 
118        return slides
119 
120 
121def build_slide_list(
122    slide_info: list[dict],
123    visible_images: list[Path],
124    temp_dir: Path,
125) -> list[tuple[Path, str]]:
126    if visible_images:
127        with Image.open(visible_images[0]) as img:
128            placeholder_size = img.size
129    else:
130        placeholder_size = (1920, 1080)
131 
132    slides = []
133    visible_idx = 0
134 
135    for info in slide_info:
136        if info["hidden"]:
137            placeholder_path = temp_dir / f"hidden-{info['name']}.jpg"
138            placeholder_img = create_hidden_placeholder(placeholder_size)
139            placeholder_img.save(placeholder_path, "JPEG")
140            slides.append((placeholder_path, f"{info['name']} (hidden)"))
141        else:
142            if visible_idx < len(visible_images):
143                slides.append((visible_images[visible_idx], info["name"]))
144                visible_idx += 1
145 
146    return slides
147 
148 
149def create_hidden_placeholder(size: tuple[int, int]) -> Image.Image:
150    img = Image.new("RGB", size, color="#F0F0F0")
151    draw = ImageDraw.Draw(img)
152    line_width = max(5, min(size) // 100)
153    draw.line([(0, 0), size], fill="#CCCCCC", width=line_width)
154    draw.line([(size[0], 0), (0, size[1])], fill="#CCCCCC", width=line_width)
155    return img
156 
157 
158def convert_to_images(pptx_path: Path, temp_dir: Path) -> list[Path]:
159    pdf_path = temp_dir / f"{pptx_path.stem}.pdf"
160 
161    result = subprocess.run(
162        [
163            "soffice",
164            "--headless",
165            "--convert-to",
166            "pdf",
167            "--outdir",
168            str(temp_dir),
169            str(pptx_path),
170        ],
171        capture_output=True,
172        text=True,
173        env=get_soffice_env(),
174    )
175    if result.returncode != 0 or not pdf_path.exists():
176        raise RuntimeError("PDF conversion failed")
177 
178    result = subprocess.run(
179        [
180            "pdftoppm",
181            "-jpeg",
182            "-r",
183            str(CONVERSION_DPI),
184            str(pdf_path),
185            str(temp_dir / "slide"),
186        ],
187        capture_output=True,
188        text=True,
189    )
190    if result.returncode != 0:
191        raise RuntimeError("Image conversion failed")
192 
193    return sorted(temp_dir.glob("slide-*.jpg"))
194 
195 
196def create_grids(
197    slides: list[tuple[Path, str]],
198    cols: int,
199    width: int,
200    output_path: Path,
201) -> list[str]:
202    max_per_grid = cols * (cols + 1)
203    grid_files = []
204 
205    for chunk_idx, start_idx in enumerate(range(0, len(slides), max_per_grid)):
206        end_idx = min(start_idx + max_per_grid, len(slides))
207        chunk_slides = slides[start_idx:end_idx]
208 
209        grid = create_grid(chunk_slides, cols, width)
210 
211        if len(slides) <= max_per_grid:
212            grid_filename = output_path
213        else:
214            stem = output_path.stem
215            suffix = output_path.suffix
216            grid_filename = output_path.parent / f"{stem}-{chunk_idx + 1}{suffix}"
217 
218        grid_filename.parent.mkdir(parents=True, exist_ok=True)
219        grid.save(str(grid_filename), quality=JPEG_QUALITY)
220        grid_files.append(str(grid_filename))
221 
222    return grid_files
223 
224 
225def create_grid(
226    slides: list[tuple[Path, str]],
227    cols: int,
228    width: int,
229) -> Image.Image:
230    font_size = int(width * FONT_SIZE_RATIO)
231    label_padding = int(font_size * LABEL_PADDING_RATIO)
232 
233    with Image.open(slides[0][0]) as img:
234        aspect = img.height / img.width
235    height = int(width * aspect)
236 
237    rows = (len(slides) + cols - 1) // cols
238    grid_w = cols * width + (cols + 1) * GRID_PADDING
239    grid_h = rows * (height + font_size + label_padding * 2) + (rows + 1) * GRID_PADDING
240 
241    grid = Image.new("RGB", (grid_w, grid_h), "white")
242    draw = ImageDraw.Draw(grid)
243 
244    try:
245        font = ImageFont.load_default(size=font_size)
246    except Exception:
247        font = ImageFont.load_default()
248 
249    for i, (img_path, slide_name) in enumerate(slides):
250        row, col = i // cols, i % cols
251        x = col * width + (col + 1) * GRID_PADDING
252        y_base = (
253            row * (height + font_size + label_padding * 2) + (row + 1) * GRID_PADDING
254        )
255 
256        label = slide_name
257        bbox = draw.textbbox((0, 0), label, font=font)
258        text_w = bbox[2] - bbox[0]
259        draw.text(
260            (x + (width - text_w) // 2, y_base + label_padding),
261            label,
262            fill="black",
263            font=font,
264        )
265 
266        y_thumbnail = y_base + label_padding + font_size + label_padding
267 
268        with Image.open(img_path) as img:
269            img.thumbnail((width, height), Image.Resampling.LANCZOS)
270            w, h = img.size
271            tx = x + (width - w) // 2
272            ty = y_thumbnail + (height - h) // 2
273            grid.paste(img, (tx, ty))
274 
275            if BORDER_WIDTH > 0:
276                draw.rectangle(
277                    [
278                        (tx - BORDER_WIDTH, ty - BORDER_WIDTH),
279                        (tx + w + BORDER_WIDTH - 1, ty + h + BORDER_WIDTH - 1),
280                    ],
281                    outline="gray",
282                    width=BORDER_WIDTH,
283                )
284 
285    return grid
286 
287 
288if __name__ == "__main__":
289    main()
290