CodeGym /Java Course /Python SELF EN /Using Templates to Create Automated Reports

Using Templates to Create Automated Reports

Python SELF EN

Level 44 , Lesson 4

Available

1. Automated Reports

Welcome to the world of report automation! If you’ve ever dreamed of making reports as simple as clicking a button, you're in the right place. Today, we will learn how to create automated reports using templates. We’ll dive into optimizing this process to avoid repetitive tasks and make your reports as cool as your most confident Python script.

Why Templates?

Nobody likes doing boring, repetitive work, especially when it comes to reports. What if every report could be generated automatically, taking in data and placing it into a predefined format? Templates let us create a base structure that can be reused multiple times with new data. It saves time and nerves, and also makes reports consistent and polished.

Benefits of Using Templates:

Speed and Efficiency: A prepared template lets you produce reports faster than ever.
Uniform Style: All reports have the same style, which looks professional and easy on the eyes.
Fewer Errors: A pre-tested structure minimizes formatting mistakes.
Ease of Modification: Changes to the template apply to all reports, simplifying maintenance.

2. Creating a Simple Report Template

Key Elements of PDF Templates in ReportLab

To create report templates in ReportLab, you can use the following key components:

Text and Headings: Use text elements to create titles, subtitles, and body text.
Tables: For presenting data in table format.
Graphic Elements: Lines, rectangles, circles, and other shapes for visual decoration.
Images: Adding logos and other images for professional design.

Creating a Template with SimpleDocTemplate

In ReportLab, the SimpleDocTemplate class allows you to create PDFs with a predefined structure. This class supports adding text, tables, and other elements via an elements list, making it easier to create structured documents.

Creating a PDF Report Template with Text and a Table

Python


from reportlab.lib.pagesizes import A4
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
from reportlab.lib import colors

# Function to create a report template
def create_pdf_template(filename="report_template.pdf"):
    doc = SimpleDocTemplate(filename, pagesize=A4)
    styles = getSampleStyleSheet()
    elements = []

    # Report title
    title_style = ParagraphStyle(
        "TitleStyle",
        parent=styles["Title"],
        fontSize=20,
        textColor=colors.darkblue,
        alignment=1,
        spaceAfter=20,
    )
    title = Paragraph("Sales Report Template", title_style)
    elements.append(title)

    # Subtitle
    subtitle_style = ParagraphStyle(
        "SubtitleStyle",
        parent=styles["Heading2"],
        fontSize=14,
        textColor=colors.gray,
        alignment=1,
        spaceAfter=10,
    )
    subtitle = Paragraph("Quarterly Report", subtitle_style)
    elements.append(subtitle)

    # Main text
    intro_text = """
    This report template is designed to present sales data by region and product category.
    The data updates automatically, making the template suitable for regular reporting.
    """
    elements.append(Paragraph(intro_text, styles["BodyText"]))
    elements.append(Spacer(1, 20))

    # Table for data
    table_data = [["Category", "Region", "Sales"]]
    # Sample data for the table (will be replaced with dynamic data)
    sample_data = [["Product A", "North", "1200"], ["Product B", "South", "1300"], ["Product C", "West", "1100"]]
    table_data.extend(sample_data)

    # Styling the table
    table_style = TableStyle([
        ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
        ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
        ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
        ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
        ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
        ('GRID', (0, 0), (-1, -1), 1, colors.black),
    ])

    table = Table(table_data)
    table.setStyle(table_style)
    elements.append(table)

    # Saving the PDF
    doc.build(elements)
    print(f"Report template successfully saved as {filename}")

# Creating the report template
create_pdf_template()

Explanation of the Code

Title and Subtitle: Styles TitleStyle and SubtitleStyle are used to format the title and subtitle, making them easy to read and visually appealing.
Main Text: The text explains that the report is a template designed for automating reports.
Table: The table serves as a structure to be filled with data. Sample data (sample_data) can be replaced with real values during report generation.
Saving: SimpleDocTemplate saves the PDF as report_template.pdf.

3. Populating the Template with Data

Automatically Filling the Template with Data

Now that we have a basic template, we can create a function that takes data and automatically fills the table. This is useful for generating reports where data comes from a database, API, or file.

Function to Automatically Fill the Template

Python


def fill_pdf_template(data, filename="filled_report.pdf"):
    doc = SimpleDocTemplate(filename, pagesize=A4)
    styles = getSampleStyleSheet()
    elements = []

    # Report title
    title = Paragraph("Sales Report", styles["Title"])
    elements.append(title)

    # Subtitle
    subtitle = Paragraph("Sales Data for the Specified Period", styles["Heading2"])
    elements.append(subtitle)
    elements.append(Spacer(1, 20))

    # Dynamically filling the table with data
    table_data = [["Category", "Region", "Sales"]] + data
    table = Table(table_data)

    # Applying styles to the table
    table.setStyle(TableStyle([
        ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
        ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
        ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
        ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
        ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
        ('GRID', (0, 0), (-1, -1), 1, colors.black),
    ]))

    elements.append(table)

    # Saving the PDF
    doc.build(elements)
    print(f"Report successfully saved as {filename}")

# Example data for filling the template
data = [
    ["Product A", "North", "1200"],
    ["Product B", "South", "1300"],
    ["Product C", "West", "1100"],
]

# Filling the template with data
fill_pdf_template(data)

Code Explanation

The fill_pdf_template Function: This function takes data as a list and inserts it into the template's table. It replaces sample data with actual values that the function receives.
Creating a Table with Dynamic Data: Data is added to the table headers, creating a complete table ready for the report.
Saving the Report: The final report is saved as filled_report.pdf.

Automating Report Creation Using the Template

The report creation process can be fully automated, especially if the data updates regularly. For example, you can create a function that pulls data from a database, uploads it to the template, and saves the report every month.

Python


import datetime

def generate_monthly_report(data):
    # Creating a filename based on the current date
    today = datetime.date.today()
    filename = f"sales_report_{today.strftime('%Y_%m')}.pdf"

    # Filling the template with data and saving
    fill_pdf_template(data, filename)
    print(f"Monthly report saved as '{filename}'.")

# Example data for a monthly report

4. Flexibility of Using Templates

The advantage of working with templates is that you can quickly adapt them for various reports. Let’s say you want to add a chart or extra table to the report. With reportlab, this becomes super easy.

Adding Charts and Tables

Here's how you can add a table to the report:

Python


from reportlab.lib import colors
from reportlab.lib.pagesizes import letter
from reportlab.platypus import SimpleDocTemplate, Table, TableStyle

# Function to create a report with a table
def create_report_with_table(output_path):
    doc = SimpleDocTemplate(output_path, pagesize=letter)
    elements = []

    # Example data for the table
    data = [['Column 1', 'Column 2', 'Column 3'],
            ['Data 1', 'Data 2', 'Data 3'],
            ['Data A', 'Data B', 'Data C']]

    table = Table(data)
    style = TableStyle([
        ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
        ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
        ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
        ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
        ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
        ('GRID', (0, 0), (-1, -1), 1, colors.black),
    ])
    table.setStyle(style)

    elements.append(table)
    doc.build(elements)

# Generate the report with a table
create_report_with_table("report_with_table.pdf")

Advantages of Report Automation

Automating reports using templates makes creating complex documents easier and frees you up to focus on analyzing data rather than formatting it. In the future, when your boss asks for “that same report, but with last month’s data,” you can wave your magic wand of PyPDF2 and ReportLab to add your data to an existing template. It’s like having a superpower, without having to wear a Python-logo hat.

Armed with these tools, you’re now ready to create reports that are not only informative but also aesthetically pleasing, with minimal effort. Try integrating different analytics into your reports to enhance their value and quality. Good luck creating templates that will impress your colleagues and management!

Previous Previous lesson

Next Next lesson

Comments

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION