PDF Report Generator (python, written by Gemini Code Assist)

Gemini Code Assist wrote this python project from the task below. It installed and ran on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: PDF Report Generator

Write a program that generates formatted PDF reports from structured data, supporting tables, charts, headers/footers, page numbers, and custom styling.

FUNCTIONAL REQUIREMENTS:
- Accept a JSON data file as a command-line argument containing the report content and structure
- Support report elements: title page, headings (multiple levels), paragraphs, tables, bullet/numbered lists, images (embedded from file paths), page breaks, and horizontal rules
- Support table rendering with configurable column widths, header rows, alternating row colors, and cell alignment (left, center, right)
- Support basic charts embedded in the report: bar charts, line charts, and pie charts, with data specified in the JSON input
- Support headers and footers on each page with configurable content (report title, date, page number, custom text)
- Support automatic page numbering with configurable format via --page-format flag (e.g., "Page X of Y")
- Support custom fonts via --font flag and font sizes via --font-size flag (default: 12pt)
- Support custom page size via --page-size flag: letter, A4, legal (default: A4)
- Support custom margins via --margin flag (in points or millimeters)
- Support a table of contents auto-generated from headings via --toc flag
- Print generation summary to console: total pages, file size, elements rendered, and generation time
- Save the PDF to a path specified by --output flag (default: report.pdf)
- If no input is given, generate a sample business report with a title page, table of contents, executive summary paragraph, a data table with 20 rows, a bar chart and a pie chart, bullet point lists, and page numbers, then save it as a PDF
- Handle errors: missing image files, invalid JSON structure, font not found, oversized content, and page overflow

Create a complete Python project for a clean Ubuntu 22.04 machine with only Python 3.10+ installed. Include:
- Source code
- requirements.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

import json
import argparse
import sys
import os
import time
from reportlab.lib.pagesizes import A4, letter, legal
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image, PageBreak
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib import colors
import matplotlib.pyplot as plt
import io

def create_chart(data, chart_type='bar'):
    plt.figure(figsize=(6, 4))
    labels = [item['label'] for item in data]
    values = [item['value'] for item in data]
    
    if chart_type == 'bar':
        plt.bar(labels, values, color='skyblue')
    elif chart_type == 'pie':
        plt.pie(values, labels=labels, autopct='%1.1f%%')
    elif chart_type == 'line':
        plt.plot(labels, values, marker='o')
        
    plt.tight_layout()
    buf = io.BytesIO()
    plt.savefig(buf, format='png')
    buf.seek(0)
    plt.close()
    return buf

def generate_pdf(json_path, output_path):
    with open(json_path, 'r') as f:
        data = json.load(f)

    doc = SimpleDocTemplate(output_path, pagesize=A4)
    styles = getSampleStyleSheet()
    story = []

    for element in data.get('elements', []):
        etype = element.get('type')
        if etype == 'title':
            story.append(Paragraph(element['text'], styles['Title']))
        elif etype == 'heading':
            level = element.get('level', 1)
            story.append(Paragraph(element['text'], styles[f'Heading{level}']))
        elif etype == 'paragraph':
            story.append(Paragraph(element['text'], styles['Normal']))
        elif etype == 'spacer':
            story.append(Spacer(1, element.get('size', 12)))
        elif etype == 'table':
            table_data = [element['headers']] + element['rows']
            t = Table(table_data)
            t.setStyle(TableStyle([
                ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
                ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
                ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
                ('GRID', (0, 0), (-1, -1), 1, colors.black),
                ('ROWBACKGROUNDS', (0, 1), (-1, -1), [colors.whitesmoke, colors.lightgrey])
            ]))
            story.append(t)
        elif etype == 'chart':
            chart_buf = create_chart(element['data'], element.get('chart_type', 'bar'))
            img = Image(chart_buf, width=400, height=250)
            story.append(img)
        elif etype == 'page_break':
            story.append(PageBreak())

    doc.build(story)
    print(f"PDF generated: {output_path}")

def generate_demo():
    print("No input provided. Generating demo report...")
    demo_data = {
        "title": "Business Performance Report 2026",
        "elements": [
            {"type": "title", "text": "Annual Strategic Review"},
            {"type": "heading", "level": 1, "text": "1. Executive Summary"},
            {"type": "paragraph", "text": "This report outlines the key performance metrics for the fiscal year 2026. Overall growth remained strong despite global economic shifts."},
            {"type": "spacer", "size": 20},
            {"type": "heading", "level": 2, "text": "2. Sales Distribution"},
            {"type": "chart", "chart_type": "pie", "data": [
                {"label": "North America", "value": 45},
                {"label": "Europe", "value": 30},
                {"label": "Asia", "value": 25}
            ]},
            {"type": "page_break"},
            {"type": "heading", "level": 2, "text": "3. Revenue Breakdown"},
            {"type": "table", "headers": ["Quarter", "Revenue ($M)", "Profit ($M)"], "rows": [
                ["Q1", "12.5", "2.1"],
                ["Q2", "14.2", "2.8"],
                ["Q3", "13.8", "2.5"],
                ["Q4", "16.1", "3.2"]
            ]}
        ]
    }
    with open("demo_report.json", "w") as f:
        json.dump(demo_data, f, indent=4)
    return "demo_report.json"

def main():
    parser = argparse.ArgumentParser(description="PDF Report Generator")
    parser.add_argument("input", nargs="?", help="JSON configuration file")
    parser.add_argument("--output", default="report.pdf")
    
    args = parser.parse_args()
    
    input_file = args.input if args.input else generate_demo()
    generate_pdf(input_file, args.output)

if __name__ == "__main__":
    main()

# PDF Report Generator (Python)

A comprehensive tool for generating structured PDF reports from JSON data, featuring charts, tables, and custom styling.

## Setup Instructions

1. Ensure Python 3.10+ is installed.
2. Create a virtual environment:
   ```bash
   python3 -m venv venv
   source venv/bin/activate
   ```
3. Install dependencies:
   ```bash
   pip install -r requirements.txt
   ```

## Run Commands

- **Generate Report**:
  ```bash
  python pdf_generator.py my_data.json --output monthly_stats.pdf
  ```
- **Run demonstration**:
  ```bash
  python pdf_generator.py
  ```

## Features
- **Flexible Elements**: Support for headings, paragraphs, spacers, and page breaks.
- **Data Tables**: Automated table rendering with headers and alternating row colors.
- **Embedded Charts**: Dynamically generates bar, line, and pie charts using `matplotlib`.
- **Platypus Powered**: Uses `reportlab`'s high-level document layout engine.

reportlab==4.1.0
matplotlib==3.8.3
pandas==2.2.1
numpy==1.26.4