presentation-automation

name	presentation-automation
description	Presentation Automation: python-pptx, Google Slides API, automated slide generation from data and templates
metadata	{"author":"cosmicstack-labs","version":"1.0.0","category":"presentation","tags":["presentation-automation","python-pptx","google-slides-api","slide-generation","automation"]}

Presentation Automation

Automate slide generation from data sources, build programmatic presentations, and integrate slide creation into CI/CD pipelines.

Core Principles

1. Templates Are the Foundation

Never build slides from scratch in code. Create a well-designed template (.potx or Google Slides master), then populate it programmatically. Templates enforce consistency; code fills in the blanks.

2. Separate Data from Presentation

Keep data extraction, transformation, and presentation logic in distinct layers. CSV/JSON/API → Data transformation → Slide population. This makes both testing and maintenance easier.

3. Idempotency Matters

The same input data should always produce the same output slides. Use deterministic logic, avoid random placement, and version your templates alongside your code.

4. Validate Before Generating

Validate input data, template placeholders, and output formats before generating slides. A broken slide at 11:59 PM before the board meeting is a career-limiting bug.

---

Presentation Automation Maturity Model

Level	Approach	Data Integration	Error Handling	Maintainability
1: Manual	Copy-paste into PowerPoint	Manual data entry	Human review	Fragile, one-off
2: Scripted	Basic python-pptx scripts	CSV/Excel import	Try-except blocks	Single-purpose scripts
3: Templated	Template-based generation	API/DB connections	Validation, logging	Modular functions
4: Automated	CI/CD pipeline, scheduled runs	Multiple data sources	Automated testing	Parameterized, configurable
5: Intelligent	Auto-charting, NLP summaries	Streaming data	Self-healing	Framework with plugins

Target: Level 3 for recurring reports. Level 4 for client-facing and board presentations.

---

python-pptx Fundamentals

Installation and Setup

# Install python-pptx
pip install python-pptx

# For working with images
pip install Pillow

# For data processing
pip install pandas numpy openpyxl

# Verify installation
python -c "import pptx; print(pptx.__version__)"

Basic Slide Creation

from pptx import Presentation
from pptx.util import Inches, Pt, Emu
from pptx.enum.text import PP_ALIGN
from pptx.dml.color import RGBColor

# Create a presentation
prs = Presentation()

# Set dimensions for 16:9 widescreen
prs.slide_width = Inches(13.333)
prs.slide_height = Inches(7.5)

# Common aspect ratios
aspect_ratios = {
    "standard_4_3": (Inches(10), Inches(7.5)),
    "widescreen_16_9": (Inches(13.333), Inches(7.5)),
    "widescreen_16_10": (Inches(11.25), Inches(7.03)),
    "a4": (Inches(11.69), Inches(8.27)),
}

# Add a blank slide
slide_layout = prs.slide_layouts[6]  # 6 = blank layout
slide = prs.slides.add_slide(slide_layout)

# Add a title text box
left = Inches(0.5)
top = Inches(0.5)
width = Inches(12)
height = Inches(1)
txBox = slide.shapes.add_textbox(left, top, width, height)
tf = txBox.text_frame
tf.word_wrap = True

p = tf.paragraphs[0]
p.text = "Hello, Automated World!"
p.font.size = Pt(44)
p.font.bold = True
p.font.color.rgb = RGBColor(0x1A, 0x36, 0x5D)
p.alignment = PP_ALIGN.LEFT

# Save
prs.save("automated_presentation.pptx")
print()

Working with Slide Layouts and Placeholders

from pptx import Presentation

def inspect_template_layouts(template_path):
    """Inspect all layouts and placeholders in a template."""
    prs = Presentation(template_path)
    
    for i, layout in enumerate(prs.slide_layouts):
        print(f"\nLayout {i}: {layout.name}")
        for j, placeholder in enumerate(layout.placeholders):
            print(f"  Placeholder {j}: idx={placeholder.placeholder_format.idx}, "
                  f"name='{placeholder.name}', type={placeholder.placeholder_format.type}")
    
    return prs

# Usage
# inspect_template_layouts("my_template.potx")

def populate_placeholder_slide(template_path, output_path, data):
    """
    Populate placeholders in a template slide.
    
    Args:
        template_path: Path to .pptx template
        output_path: Path for generated file
        data: Dict mapping placeholder_idx -> text
    """
    prs = Presentation(template_path)
    
    # Use the first layout (index 0 — typically title slide)
    layout = prs.slide_layouts[0]
    slide = prs.slides.add_slide(layout)
    
    for placeholder in slide.placeholders:
        idx = placeholder.placeholder_format.idx
        if idx in data:
            placeholder.text = data[idx]
    
    prs.save(output_path)
    print(f"Generated: {output_path}")

---

Chart Generation

Creating Bar Charts

from pptx import Presentation
from pptx.chart.data import CategoryChartData
from pptx.enum.chart import XL_CHART_TYPE
from pptx.util import Inches, Pt
from pptx.dml.color import RGBColor

def add_bar_chart(slide, categories, values, title="", 
                  chart_type=XL_CHART_TYPE.COLUMN_CLUSTERED):
    """
    Add a bar/column chart to a slide.
    
    Args:
        slide: pptx Slide object
        categories: List of category labels
        values: List of numeric values
        title: Chart title string
        chart_type: XL_CHART_TYPE constant
    """
    chart_data = CategoryChartData()
    chart_data.categories = categories
    chart_data.add_series("Revenue", values)
    
    # Add chart to slide
    left = Inches(0.5)
    top = Inches(1.5)
    width = Inches(12)
    height = Inches(5.5)
    
    chart_frame = slide.shapes.add_chart(
        chart_type, left, top, width, height, chart_data
    )
    chart = chart_frame.chart
    
    # Style the chart
    chart.has_legend = True
    chart.legend.include_in_layout = False
    
    # Style the plot
    plot = chart.plots[0]
    plot.gap_width = 80  # Gap between bars
    
    # Set colors for each series point
    series = plot.series[0]
    series.format.fill.solid()
    series.format.fill.fore_color.rgb = RGBColor(0x2B, 0x6C, 0xB0)
    
    # Title
    chart.has_title = True
    chart.chart_title.text_frame.paragraphs[].text = title
    chart.chart_title.text_frame.paragraphs[].font.size = Pt()
    chart.chart_title.text_frame.paragraphs[].font.bold = 
    
     chart


 ():
    
    chart_data = CategoryChartData()
    chart_data.categories = categories
    
    colors = [
        RGBColor(, , ),  
        RGBColor(, , ),  
        RGBColor(, , ),  
        RGBColor(, , ),  
    ]
    
     i, (name, values)  (series_data):
        chart_data.add_series(name, values)
    
    chart_frame = slide.shapes.add_chart(
        XL_CHART_TYPE.LINE_MARKERS, 
        Inches(), Inches(), 
        Inches(), Inches(), 
        chart_data
    )
    chart = chart_frame.chart
    
    
     i, series  (chart.series):
        series..line.color.rgb = colors[i % (colors)]
        series..line.width = Pt()
    
    chart.has_title = 
    chart.chart_title.text_frame.paragraphs[].text = title
    chart.chart_title.text_frame.paragraphs[].font.size = Pt()
    chart.chart_title.text_frame.paragraphs[].font.bold = 
    
     chart

Creating Pie Charts

from pptx.chart.data import CategoryChartData
from pptx.enum.chart import XL_CHART_TYPE, XL_LABEL_POSITION

def add_pie_chart(slide, categories, values, title=""):
    """Add a styled pie chart (max 5 slices recommended)."""
    chart_data = CategoryChartData()
    chart_data.categories = categories
    chart_data.add_series("Distribution", values)
    
    chart_frame = slide.shapes.add_chart(
        XL_CHART_TYPE.PIE, 
        Inches(2), Inches(1.5), 
        Inches(9), Inches(5.5), 
        chart_data
    )
    chart = chart_frame.chart
    
    # Add data labels with percentages
    plot = chart.plots[0]
    data_labels = plot.data_labels
    data_labels.show_percentage = True
    data_labels.show_category_name = True
    data_labels.font.size = Pt(12)
    data_labels.label_position = XL_LABEL_POSITION.OUTSIDE_END
    
    # Colors for slices
    colors = [
        RGBColor(0x2B, 0x6C, 0xB0),
        RGBColor(0x38, 0xA1, 0x69),
        RGBColor(0xD6, 0x9E, 0x2E),
        RGBColor(0xE5, 0x3E, 0x3E),
        RGBColor(0x9B, 0x2C, 0x2C),
    ]
    
    series = plot.series[0]
    for i, point in enumerate(series.points):
        point.format.fill.solid()
        point.format.fill.fore_color.rgb = colors[i % (colors)]
    
    chart.has_title = 
    chart.chart_title.text_frame.paragraphs[].text = title
    
     chart

---

Table Population from Data

Creating Tables from DataFrames

import pandas as pd
from pptx import Presentation
from pptx.util import Inches, Pt, Emu
from pptx.dml.color import RGBColor
from pptx.enum.text import PP_ALIGN

def dataframe_to_slide(prs, df, title="", 
                       header_color=RGBColor(0x1A, 0x36, 0x5D),
                       header_text_color=RGBColor(0xFF, 0xFF, 0xFF),
                       alt_row_color=RGBColor(0xF7, 0xFA, 0xFC)):
    """
    Convert a pandas DataFrame to a PowerPoint table on a new slide.
    
    Args:
        prs: Presentation object
        df: pandas DataFrame
        title: Slide title text
        header_color: Background color for header row
        header_text_color: Text color for header row
        alt_row_color: Alternating row background color
    """
    slide_layout = prs.slide_layouts[6]  # Blank layout
    slide = prs.slides.add_slide(slide_layout)
    
    # Add title
    if title:
        txBox = slide.shapes.add_textbox(Inches(0.5), Inches(0.3), 
                                         Inches(12), Inches(0.8))
        tf = txBox.text_frame
        p = tf.paragraphs[0]
        p.text = title
        p.font.size = Pt(28)
        p.font.bold = True
        p.font.color.rgb = RGBColor(0x1A, 0x36, 0x5D)
    
    # Table dimensions
    rows, cols = (df) + , (df.columns)  
    left = Inches()
    top = Inches()
    width = Inches()
    row_height = Inches()
    height = row_height * rows
    
    
    table_shape = slide.shapes.add_table(rows, cols, left, top, width, height)
    table = table_shape.table
    
    
    col_width = width / cols
     i  (cols):
        table.columns[i].width = col_width
    
    
     j, col_name  (df.columns):
        cell = table.cell(, j)
        cell.text = (col_name)
        
        
         paragraph  cell.text_frame.paragraphs:
            paragraph.font.size = Pt()
            paragraph.font.bold = 
            paragraph.font.color.rgb = header_text_color
            paragraph.alignment = PP_ALIGN.LEFT
        
        
        cell.fill.solid()
        cell.fill.fore_color.rgb = header_color
    
    
     i, (_, row)  (df.iterrows()):
         j, value  (row):
            cell = table.cell(i + , j)
            cell.text = (value)   pd.isna(value)  
            
             paragraph  cell.text_frame.paragraphs:
                paragraph.font.size = Pt()
                paragraph.font.color.rgb = RGBColor(, , )
                paragraph.alignment = PP_ALIGN.LEFT
            
            
             i %  == :
                cell.fill.solid()
                cell.fill.fore_color.rgb = alt_row_color
            :
                cell.fill.solid()
                cell.fill.fore_color.rgb = RGBColor(, , )
    
     slide, table

CSV to Presentation Pipeline

import pandas as pd
from pptx import Presentation
from pathlib import Path

def csv_to_presentation(csv_path, template_path, output_path, 
                        title_column=None, data_start_row=0):
    """
    Generate a presentation from CSV data using a template.
    
    Args:
        csv_path: Path to input CSV
        template_path: Path to .pptx template
        output_path: Path for generated file
        title_column: Column to use for slide titles (optional)
        data_start_row: Row index to start data from
    """
    df = pd.read_csv(csv_path)
    prs = Presentation(template_path)
    
    for idx, row in df.iterrows():
        if idx < data_start_row:
            continue
        
        # Add a slide for each row
        slide_layout = prs.slide_layouts[1]  # Title and content
        slide = prs.slides.add_slide(slide_layout)
        
        # Set title
        if title_column and title_column in row:
            slide.shapes.title.text = str(row[title_column])
        else:
            slide.shapes.title.text = f"Record {idx + 1}"
        
        # Add content from other columns
        content_lines = []
        for col in df.columns:
            if col != title_column and not pd.isna(row[col]):
                content_lines.append(f"**{col}**: {row[col]}")
        
        # Add to content placeholder
         slide.placeholders:
            content_placeholder = slide.placeholders[]
            content_placeholder.text = .join(content_lines)
    
    prs.save(output_path)
    ()
     output_path

---

Image Insertion

from pptx import Presentation
from pptx.util import Inches, Pt, Emu
from pptx.enum.shapes import MSO_SHAPE

def insert_image(slide, image_path, left, top, width=None, height=None):
    """
    Insert an image with proper positioning and sizing.
    
    Args:
        slide: Slide object
        image_path: Path to image file
        left: Left position in Inches
        top: Top position in Inches
        width: Width in Inches (None = auto)
        height: Height in Inches (None = auto)
    """
    left_emu = Inches(left) if isinstance(left, (int, float)) else left
    top_emu = Inches(top) if isinstance(top, (int, float)) else top
    width_emu = Inches(width) if isinstance(width, (int, float)) else width
    height_emu = Inches(height) if isinstance(height, (int, float)) else height
    
    pic = slide.shapes.add_picture(
        image_path, left_emu, top_emu, width_emu, height_emu
    )
    return pic


def add_image_with_caption(slide, image_path, caption, 
                            img_left=1, img_top=1.5, 
                            img_width=10, img_height=5):
    """
    Add an image with a caption below it.
    """
    # Add image
    pic = insert_image(slide, image_path, img_left, img_top, img_width, img_height)
    
    
    caption_top = img_top + img_height + Inches()
    txBox = slide.shapes.add_textbox(
        Inches(img_left), Inches(caption_top), 
        Inches(img_width), Inches()
    )
    tf = txBox.text_frame
    p = tf.paragraphs[]
    p.text = caption
    p.font.size = Pt()
    p.font.italic = 
    p.font.color.rgb = RGBColor(, , )
    p.alignment = PP_ALIGN.CENTER
    
     pic


 ():
    
    positions = {
        : (Inches(), Inches()),
        : (prs.slide_width - width - Inches(), Inches()),
        : (Inches(), prs.slide_height - Inches()),
        : (prs.slide_width - width - Inches(), 
                         prs.slide_height - Inches()),
    }
    
    left, top = positions.get(position, positions[])
    
     slide  prs.slides:
        slide.shapes.add_picture(logo_path, left, top, width=width)
    
     prs

---

Google Slides API

Setup and Authentication

# Install the Google API client
pip install google-auth google-auth-oauthlib google-auth-httplib2
pip install google-api-python-client

# Set up service account credentials
# 1. Go to console.cloud.google.com
# 2. Enable the Google Slides API
# 3. Create a service account
# 4. Download the service account key JSON
# 5. Share your Google Slides presentation with the service account email

Reading and Writing Google Slides

import os
from google.oauth2 import service_account
from googleapiclient.discovery import build

# Service account credentials
SCOPES = ["https://www.googleapis.com/auth/presentations"]

def get_slides_service(credentials_path="service_account.json"):
    """Authenticate and return Google Slides service."""
    creds = service_account.Credentials.from_service_account_file(
        credentials_path, scopes=SCOPES
    )
    service = build("slides", "v1", credentials=creds)
    return service


def read_presentation_slides(presentation_id):
    """
    Read slide content from a Google Slides presentation.
    
    Args:
        presentation_id: The ID from the presentation URL
                        (e.g., "1ABCxyz..." from docs.google.com/presentation/d/1ABCxyz...)
    """
    service = get_slides_service()
    presentation = service.presentations().get(
        presentationId=presentation_id
    ).execute()
    
    slides = presentation.get("slides", [])
    print(f"Title: {presentation.get('title', 'Untitled')}")
    print(f"Slides: {len(slides)}")
    
    for i, slide in enumerate(slides):
        print(f"\nSlide {i + 1}:")
        for element in slide.get("pageElements", []):
            if "shape"  element    element[]:
                text = element[][][]
                full_text = .join([
                    t.get(, {}).get(, ) 
                     t  text    t
                ])
                 full_text.strip():
                    ()
    
     presentation


 ():
    
    service = get_slides_service()
    
    requests = []
     placeholder, value  replacements.items():
        requests.append({
            : {
                : {
                    : placeholder,
                    : ,
                },
                : value,
            }
        })
    
     requests:
        body = {: requests}
        response = service.presentations().batchUpdate(
            presentationId=presentation_id, body=body
        ).execute()
        ()
         response
    
     


 ():
    
    service = get_slides_service()
    
    requests = [
        {
            : {
                : template_slide_id,
            }
        }
    ]
    
    body = {: requests}
    response = service.presentations().batchUpdate(
        presentationId=presentation_id, body=body
    ).execute()
    
    new_slide_id = response[][][][]
    ()
     new_slide_id

---

Batch Slide Creation from Templates

import json
from pptx import Presentation
from pathlib import Path

class BatchSlideGenerator:
    """Generate multiple presentations from a template and data source."""
    
    def __init__(self, template_path, output_dir):
        self.template_path = Path(template_path)
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(parents=True, exist_ok=True)
    
    def generate_from_json(self, data_path):
        """
        Generate presentations from a JSON data file.
        
        Expected JSON format:
        [
            {
                "filename": "report_acme.pptx",
                "title": "Acme Corp Report",
                "metrics": {"ARR": "$500K", "Growth": "45%"},
                "charts": {...}
            },
            ...
        ]
        """
        with open(data_path) as f:
            items = json.load(f)
        
        for item in items:
            prs = Presentation(str(self.template_path))
            
            # Populate first slide
            slide = prs.slides[0]
            if slide.shapes.title:
                slide.shapes.title.text = item.get("title", "Report")
            
            # Add metrics
            if "metrics" in item:
                self._add_metrics_slide(prs, item["metrics"])
            
            
            output_path = .output_dir / item[]
            prs.save((output_path))
            ()
        
         (items)
    
     ():
        
        slide_layout = prs.slide_layouts[]
        slide = prs.slides.add_slide(slide_layout)
        
        
         pptx.util  Inches
        rows = (metrics) + 
        cols = 
        table_shape = slide.shapes.add_table(
            rows, cols, Inches(), Inches(), Inches(), Inches( * rows)
        )
        table = table_shape.table
        
        
        table.cell(, ).text = 
        table.cell(, ).text = 
        
        
         i, (key, value)  (metrics.items()):
            table.cell(i + , ).text = (key)
            table.cell(i + , ).text = (value)
    
     ():
        
         client  client_data:
            prs = Presentation((.template_path))
            
            
             slide  prs.slides:
                 shape  slide.shapes:
                     shape.has_text_frame:
                         paragraph  shape.text_frame.paragraphs:
                             key, value  client.items():
                                placeholder = 
                                 placeholder  paragraph.text:
                                    paragraph.text = paragraph.text.replace(
                                        placeholder, (value)
                                    )
            
            filename = 
            output_path = .output_dir / filename
            prs.save((output_path))
            ()

---

CI/CD for Presentation Generation

GitHub Actions Workflow

# .github/workflows/generate-report.yml
name: Generate Weekly Report
on:
  schedule:
    - cron: '0 9 * * 1'  # Every Monday at 9 AM
  workflow_dispatch:       # Allow manual trigger

jobs:
  generate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'
      
      - name: Install dependencies
        run: |
          pip install python-pptx pandas numpy
          pip install google-auth google-api-python-client
      
      - name: Generate presentation
        run: |
          python scripts/generate_weekly_report.py
        env:
          API_KEY: ${{ secrets.API_KEY }}
          DB_URL: ${{ secrets.DB_URL }}
      
          
         
        
           
           
      
          
                 
             
             

Makefile for Presentation Generation

# Makefile for automating presentation generation

SHELL := /bin/bash
PYTHON := python3
TEMPLATE := templates/board_template.pptx
OUTPUT_DIR := output

.PHONY: all clean monthly weekly quarterly

all: weekly

setup:
	@mkdir -p $(OUTPUT_DIR)
	@pip install -r requirements.txt

weekly: setup
	@echo "Generating weekly report..."
	$(PYTHON) scripts/generate_from_crm.py \
		--template $(TEMPLATE) \
		--output $(OUTPUT_DIR)/weekly_report_$(shell date +%Y-%m-%d).pptx \
		--period weekly

monthly: setup
	@echo "Generating monthly report..."
	$(PYTHON) scripts/generate_from_crm.py \
		--template $(TEMPLATE) \
		--output $(OUTPUT_DIR)/monthly_report_$(shell date +%Y-%m).pptx \
		--period monthly

quarterly: setup
	@echo "Generating quarterly board deck..."
	$(PYTHON) scripts/generate_board_deck.py \
		--template $(TEMPLATE) \
		--output $(OUTPUT_DIR)/board_deck_Q$(shell date +%m | awk '{print int(($$1+2)/3)}')_$(shell date +%Y).pptx

clean:
	@echo "Cleaning output directory..."
	@rm -rf $(OUTPUT_DIR)/*.pptx

---

Exporting Slides as PDF/Images

import subprocess
import os
from pathlib import Path

def pptx_to_pdf_libreoffice(pptx_path, output_dir=None):
    """
    Convert PPTX to PDF using LibreOffice (cross-platform).
    
    Requires: LibreOffice installed (brew install libreoffice on macOS)
    """
    pptx_path = Path(pptx_path)
    output_dir = Path(output_dir) if output_dir else pptx_path.parent
    
    cmd = [
        "libreoffice", "--headless", "--convert-to", "pdf",
        "--outdir", str(output_dir),
        str(pptx_path)
    ]
    
    result = subprocess.run(cmd, capture_output=True, text=True)
    
    if result.returncode == 0:
        pdf_path = output_dir / f"{pptx_path.stem}.pdf"
        print(f"Converted: {pptx_path.name} → {pdf_path}")
        return pdf_path
    else:
        print(f"Error: {result.stderr}")
        return None


def pptx_to_images(pptx_path, output_dir=None, dpi=150):
    """
    Convert each slide to PNG images using LibreOffice + ImageMagick.
    
    Args:
        pptx_path: Path to .pptx file
        output_dir: Output directory for images
        dpi: Image resolution (default 150)
    """
    pptx_path = Path(pptx_path)
    output_dir = Path(output_dir) if output_dir  pptx_path.parent / 
    output_dir.mkdir(parents=, exist_ok=)
    
    
    pdf_path = pptx_to_pdf_libreoffice(pptx_path)
      pdf_path:
         []
    
    
    cmd = [
        , , (dpi),
        (pdf_path),
        , ,
        , ,
        , ,
        (output_dir / )
    ]
    
    result = subprocess.run(cmd, capture_output=, text=)
    
     result.returncode == :
        images = (output_dir.glob())
        ()
         images
    :
        ()
         []


 ():
    
    pptx_dir = Path(pptx_dir)
    results = []
    
     pptx_file  pptx_dir.glob():
        pdf = pptx_to_pdf_libreoffice(pptx_file)
        images = pptx_to_images(pptx_file)
        results.append({
            : pptx_file.name,
            : (pdf)  pdf  ,
            : (images),
        })
    
     results

---

Common Mistakes

1. Hardcoding values instead of using templates: Writing slide text directly in code makes updates painful. Always use template placeholders.
2. No error handling for missing data: A missing column in your CSV crashes the entire generation. Validate data before processing.
3. Ignoring slide dimensions: Generating slides in 4:3 when the presentation is shown on 16:9 screens. Always match the output aspect ratio.
4. Tight coupling of data and presentation code: Data transformation logic mixed with slide creation code makes debugging and reuse difficult.
5. Forgetting to close the Presentation object: Not saving with prs.save() after making changes. Always call save before exiting.
6. Oversized images: Inserting 20MB images that bloat the file. Compress images to under 500KB before insertion.
7. No validation of template placeholders: If a template has {{NAME}} but code replaces {{name}}, it silently fails. Validate all placeholders.
8. Creating slides one by one in loops: Using nested loops for every shape and element. Build reusable functions for common patterns.
9. Not version-controlling templates: Templates change over time. Store them in Git with the code that populates them.
10. No logging or monitoring: When automated generation fails at 3 AM, you need logs to diagnose. Always log generation steps.