PowerPoint × Python── python-pptx でスライドの文字・表・ノートを一括で読み出す

"""Turn each deck into a Markdown outline (title + bullets by level) and flag untitled slides."""
from pathlib import Path

from pptx import Presentation
from pptx.enum.shapes import PP_PLACEHOLDER

DECKS = sorted(Path("samples").glob("*.pptx"))
TITLE_TYPES = {PP_PLACEHOLDER.TITLE, PP_PLACEHOLDER.CENTER_TITLE}


def slide_outline(slide):
    title = slide.shapes.title  # None when the slide has no title placeholder
    text = title.text_frame.text.strip() if title is not None else ""
    lines = [text or "(no title)"]
    for shape in slide.placeholders:
        if shape.placeholder_format.type in TITLE_TYPES or not shape.has_text_frame:
            continue
        for p in shape.text_frame.paragraphs:
            body = "".join(r.text for r in p.runs).strip()
            if body:
                lines.append("  " * p.level + "- " + body)
    return lines


def main():
    for path in DECKS:
        prs = Presentation(path)
        md, untitled = ["# " + path.stem], []
        for i, slide in enumerate(prs.slides, 1):
            lines = slide_outline(slide)
            if lines[0] == "(no title)":
                untitled.append("%d (%s)" % (i, slide.slide_layout.name))
            md += ["", "## %d. %s" % (i, lines[0])] + lines[1:]
        out = Path("out_outline_%s.md" % path.stem)
        out.write_text("\n".join(md) + "\n", encoding="utf-8")
        print("%s: slides %d, untitled: %s -> %s" % (path.name, len(prs.slides), ", ".join(untitled) or "none", out.name))


if __name__ == "__main__":
    main()

"""Export every table in each deck to CSV, marking merged and empty cells."""
import csv
from pathlib import Path

from pptx import Presentation

DECKS = sorted(Path("samples").glob("*.pptx"))


def iter_tables(prs):
    for s, slide in enumerate(prs.slides, 1):
        for shape in slide.shapes:
            if shape.has_table:
                yield s, shape.name, shape.table


def cell_rows(table):
    for r, row in enumerate(table.rows):
        for c, cell in enumerate(row.cells):
            if cell.is_spanned:
                state = "spanned"  # hidden under a merged cell
            elif cell.is_merge_origin:
                state = "merged %dx%d" % (cell.span_height, cell.span_width)
            else:
                state = ""
            empty = "empty" if not cell.is_spanned and not cell.text.strip() else ""
            yield r, c, state, empty, cell.text.strip()


def main():
    rows = []
    for path in DECKS:
        for s, name, table in iter_tables(Presentation(path)):
            rows += [(path.name, s, name) + rec for rec in cell_rows(table)]
    with open("out_tables.csv", "w", encoding="utf-8-sig", newline="") as f:
        w = csv.writer(f)
        w.writerow(["deck", "slide", "shape", "row", "col", "state", "flag", "text"])
        w.writerows(rows)
    tables = {(r[0], r[1], r[2]) for r in rows}
    print("tables:", len(tables), "cells:", len(rows), "empty cells:", sum(r[6] == "empty" for r in rows))
    for r in rows:
        if r[5] or r[6]:
            print(" | ".join(str(x) for x in r))


if __name__ == "__main__":
    main()

"""List speaker notes per slide without creating empty notes slides, and flag style-list terms."""
import csv
from pathlib import Path

from pptx import Presentation

DECKS = sorted(Path("samples").glob("*.pptx"))
TERMS = Path("samples/style_terms.csv")


def load_terms(path):
    with open(path, encoding="utf-8-sig", newline="") as f:
        return [row["term"] for row in csv.DictReader(f)]


def notes_text(slide):
    """None when the slide has no notes slide; never creates one."""
    if not slide.has_notes_slide:  # slide.notes_slide would create a notes slide
        return None
    frame = slide.notes_slide.notes_text_frame
    return frame.text.strip() if frame is not None else ""


def main():
    terms = load_terms(TERMS)
    rows = []
    for path in DECKS:
        missing = []
        for i, slide in enumerate(Presentation(path).slides, 1):
            title = slide.shapes.title.text_frame.text.strip() if slide.shapes.title is not None else ""
            notes = notes_text(slide)
            state = "none" if notes is None else ("empty" if not notes else "text")
            if state != "text":
                missing.append(i)
            found = [t for t in terms if notes and t in notes]
            rows.append((path.name, i, title, state, notes or "", " ".join(found)))
        print("%s: slides without notes: %s" % (path.name, missing or "none"))
    with open("out_notes.csv", "w", encoding="utf-8-sig", newline="") as f:
        w = csv.writer(f)
        w.writerow(["deck", "slide", "title", "state", "notes", "terms"])
        w.writerows(rows)
    for r in rows:
        if r[5]:
            print("term in notes:", r[0], "slide", r[1], "|", r[5], "|", r[4])


if __name__ == "__main__":
    main()

"""Find text hidden inside group shapes by walking the shape tree recursively."""
from pathlib import Path

from pptx import Presentation
from pptx.enum.shapes import MSO_SHAPE_TYPE

DECKS = sorted(Path("samples").glob("*.pptx"))


def iter_shapes(shapes, path=()):
    """Yield (group path, shape) for every shape, descending into groups."""
    for shape in shapes:
        if shape.shape_type == MSO_SHAPE_TYPE.GROUP:
            yield from iter_shapes(shape.shapes, path + (shape.name,))
        else:
            yield path, shape


def has_text(shape):
    return shape.has_text_frame and shape.text_frame.text.strip()


def main():
    for deck in DECKS:
        top = nested = 0
        for i, slide in enumerate(Presentation(deck).slides, 1):
            top += sum(1 for s in slide.shapes if has_text(s))
            for path, shape in iter_shapes(slide.shapes):
                if path and has_text(shape):
                    nested += 1
                    print("slide %d | %s > %s (id %d) | %s" % (
                        i, " > ".join(path), shape.name, shape.shape_id, shape.text_frame.text.strip()))
        print("%s: text shapes at top level %d, in groups: %d" % (deck.name, top, nested))


if __name__ == "__main__":
    main()

"""Extract pictures from decks, skip duplicates by SHA1, and list every placement in a CSV."""
import csv
from pathlib import Path

from pptx import Presentation
from pptx.enum.shapes import MSO_SHAPE_TYPE
from pptx.shapes.picture import Picture

DECKS = sorted(Path("samples").glob("*.pptx"))
OUT_DIR = Path("out_images")


def iter_pictures(shapes):
    for shape in shapes:
        if shape.shape_type == MSO_SHAPE_TYPE.GROUP:
            yield from iter_pictures(shape.shapes)
        elif isinstance(shape, Picture):
            yield shape


def main():
    OUT_DIR.mkdir(exist_ok=True)
    rows, saved = [], {}
    for deck in DECKS:
        for i, slide in enumerate(Presentation(deck).slides, 1):
            for pic in iter_pictures(slide.shapes):
                img = pic.image
                dup = "duplicate" if img.sha1 in saved else ""
                if not dup:
                    saved[img.sha1] = "%s_s%d_%s.%s" % (deck.stem, i, img.sha1[:8], img.ext)
                    (OUT_DIR / saved[img.sha1]).write_bytes(img.blob)
                w, h = img.size
                rows.append((deck.name, i, pic.name, img.content_type, "%dx%d" % (w, h),
                             "%dx%d" % img.dpi, saved[img.sha1], dup))
    with open("out_pictures.csv", "w", encoding="utf-8-sig", newline="") as f:
        wr = csv.writer(f)
        wr.writerow(["deck", "slide", "shape", "content_type", "pixels", "dpi", "file", "flag"])
        wr.writerows(rows)
    print("pictures:", len(rows), "unique files:", len(saved))
    for r in rows:
        print(" | ".join(str(x) for x in r))


if __name__ == "__main__":
    main()

"""Check every .pptx in a folder against a style list: text, groups, tables and notes."""
import csv
from collections import Counter
from pathlib import Path

from pptx import Presentation
from pptx.enum.shapes import MSO_SHAPE_TYPE

FOLDER = Path("samples")
TERMS = FOLDER / "style_terms.csv"


def load_terms(path):
    with open(path, encoding="utf-8-sig", newline="") as f:
        return list(csv.DictReader(f))


def texts(slide):
    """Yield (where, text) for text frames, table cells (also inside groups) and notes."""
    queue = [(shape, shape.name) for shape in slide.shapes]
    while queue:
        shape, where = queue.pop(0)
        if shape.shape_type == MSO_SHAPE_TYPE.GROUP:
            queue[:0] = [(s, where + ">" + s.name) for s in shape.shapes]
        elif shape.has_text_frame:
            yield where, shape.text_frame.text
        elif shape.has_table:
            for r, row in enumerate(shape.table.rows):
                for c, cell in enumerate(row.cells):
                    if not cell.is_spanned:
                        yield "%s[r%dc%d]" % (where, r, c), cell.text
    if slide.has_notes_slide and slide.notes_slide.notes_text_frame is not None:
        yield "notes", slide.notes_slide.notes_text_frame.text


def check_deck(path, terms):
    try:
        prs = Presentation(path)
    except Exception as e:  # keep going when one file cannot be opened
        return [(path.name, "", "", "", "", "open failed: %s" % type(e).__name__)]
    rows = []
    for i, slide in enumerate(prs.slides, 1):
        for where, text in texts(slide):
            for t in terms:
                if t["term"] in text:
                    rows.append((path.name, i, where, t["term"], t["action"], text.strip().replace("\n", " / ")))
    return rows


def main():
    terms = load_terms(TERMS)
    decks = sorted(FOLDER.glob("*.pptx"))
    rows = [r for path in decks for r in check_deck(path, terms)]
    with open("out_deck_check.csv", "w", encoding="utf-8-sig", newline="") as f:
        w = csv.writer(f)
        w.writerow(["deck", "slide", "where", "term", "action", "text"])
        w.writerows(rows)
    print("decks:", len(decks), "hits:", len(rows))
    for deck, n in Counter(r[0] for r in rows).most_common():
        print("  %s %d" % (deck, n))
    for r in rows[:8]:
        print(" | ".join(str(x) for x in r[:5]))


if __name__ == "__main__":
    main()

"""Build a new summary deck: one slide per source deck listing its slide titles, plus a totals table."""
from pathlib import Path

from pptx import Presentation
from pptx.util import Inches, Pt

DECKS = sorted(Path("samples").glob("deck_*.pptx"))
OUT = Path("out_summary.pptx")


def describe(path):
    titles, tables, notes = [], 0, 0
    for slide in Presentation(path).slides:
        t = slide.shapes.title
        titles.append(t.text_frame.text.strip() if t is not None else "(no title)")
        tables += sum(1 for s in slide.shapes if s.has_table)
        if slide.has_notes_slide and slide.notes_slide.notes_text_frame.text.strip():
            notes += 1
    return {"name": path.name, "titles": titles, "tables": tables, "notes": notes}


def layout(prs, name):
    found = prs.slide_layouts.get_by_name(name)
    if found is None:
        raise SystemExit("layout not found in template: %s" % name)
    return found


def build(infos, out):
    prs = Presentation()  # built-in default template; open your own .pptx to reuse its layouts
    cover = prs.slides.add_slide(layout(prs, "Title Slide"))
    cover.shapes.title.text = "Deck summary"
    cover.placeholders[1].text = "%d decks" % len(infos)
    for info in infos:
        slide = prs.slides.add_slide(layout(prs, "Title and Content"))
        slide.shapes.title.text = info["name"]
        tf = slide.placeholders[1].text_frame
        tf.text = "%d slides" % len(info["titles"])
        for i, title in enumerate(info["titles"], 1):
            p = tf.add_paragraph()
            p.text = "%d. %s" % (i, title)
            p.level = 1
    last = prs.slides.add_slide(layout(prs, "Title Only"))
    last.shapes.title.text = "Totals"
    n = len(infos) + 1
    table = last.shapes.add_table(n, 4, Inches(0.5), Inches(1.8), Inches(9), Inches(0.4) * n).table
    for c, head in enumerate(["deck", "slides", "tables", "slides with notes"]):
        table.cell(0, c).text = head
    for r, info in enumerate(infos, 1):
        for c, value in enumerate([info["name"], len(info["titles"]), info["tables"], info["notes"]]):
            table.cell(r, c).text = str(value)
            table.cell(r, c).text_frame.paragraphs[0].runs[0].font.size = Pt(14)
    prs.save(out)


def main():
    if any(OUT.resolve() == p.resolve() for p in DECKS):
        raise SystemExit("output must not overwrite an input")
    infos = [describe(p) for p in DECKS]
    build(infos, OUT)
    print("saved", OUT, "slides:", len(Presentation(OUT).slides))
    for info in infos:
        print("  %s: %d slides, %d tables, %d with notes" % (
            info["name"], len(info["titles"]), info["tables"], info["notes"]))


if __name__ == "__main__":
    main()