Open in app

Sign in

Write

Sign in

Mastering PDF Report Generation with ReportLab: A Comprehensive Tutorial Part 1

Praveen Goyal
8 min readMar 30, 2023

As a backend developer, I’ve had to generate PDF reports for a variety of projects. Initially, I used to rely on external tools or libraries to generate the reports. However, I soon realized that this approach was limiting as it didn’t provide the flexibility and customization that I required. That’s when I started exploring Python libraries for generating PDFs and came across ReportLab.

I was immediately impressed with the features and flexibility that ReportLab offered. It allowed me to generate highly customizable and professional-looking PDF reports with ease. The ability to create custom page templates, add charts, tables, and shapes, and format the text using a wide variety of fonts and styles made it an ideal choice for my projects.

Since then, I’ve used ReportLab for various projects, ranging from generating simple invoices to complex financial reports. The ease of use and flexibility of the library has made it a staple in my toolkit as a backend developer, and I highly recommend it to anyone looking to generate PDF reports in Python.

Introduction to ReportLab

ReportLab is a powerful Python library for creating complex PDF documents. It provides an extensive set of tools for generating high-quality PDF reports, including support for tables, charts, graphics, and custom fonts. In this blog cum tutorial, we’ll explore why ReportLab is a great choice for generating PDF reports, provide an introduction to the library, and provide some examples of using PageTemplates, Charts, Tables, and Shapes to create complex PDF documents.

Why Choose ReportLab?

ReportLab is a popular choice for generating PDF reports due to its ease of use, flexibility, and extensive feature set. Here are some reasons why ReportLab might be the right choice for your PDF generation needs:

  1. Easy to Use: ReportLab is easy to use, even for beginners. Its API is well-documented, and the library provides numerous examples and tutorials to help you get started.
  2. Flexible: ReportLab provides a wide range of tools for generating PDF reports, including support for text, tables, charts, and custom graphics. You can use ReportLab to create reports of any complexity, from simple one-page documents to multi-page reports with complex layouts.
  3. Extensive Feature Set: ReportLab provides extensive support for generating high-quality PDF documents. It supports a range of fonts and text styles, and provides tools for creating custom headers and footers, page numbers, and watermarks.
  4. Cost-effective: ReportLab is an open-source library, which means that it is free to use for both personal and commercial projects.

Getting Started

To get started with ReportLab, you’ll need to install the library. You can do this using pip, the Python package manager:

pip install reportlab

Once you’ve installed ReportLab, you can start using it in your Python projects. Here’s a simple example that demonstrates how to create a PDF document with some text:

from reportlab.pdfgen import canvas

# Create a new PDF document
pdf = canvas.Canvas('example.pdf')

# Add some text to the document
pdf.drawString(100, 750, "Welcome to ReportLab!")

# Save the PDF document
pdf.save()

This code creates a new PDF document using the canvas.Canvas() method and adds some text to the document using the pdf.drawString() method. Finally, the pdf.save() method is used to save the document to disk.

Using Canvas

In ReportLab, a Canvas is an object that represents a page in a PDF document. The Canvas provides a drawing interface that allows you to add various elements such as lines, shapes, text, and images to the page.

When you create a Canvas object, you specify the page size and other options such as the margins and orientation. You can then use the various drawing methods provided by the Canvas to add content to the page. Once you've finished drawing the page, you can save the PDF document using the save() method of the Canvas.

The Canvas object also provides various options for controlling the appearance of the content you add to the page. For example, you can set the stroke color and line width for lines, specify fonts and font sizes for text, and control the position and size of images.

Overall, the Canvas is a powerful and flexible tool for generating custom PDF documents with ReportLab, and is essential for creating more complex PDF reports with customized layouts and design elements.

Here’s an example of using the ReportLab Canvas object:

from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas

# Create a new PDF with canvas
pdf_canvas = canvas.Canvas("example_canvas.pdf", pagesize=letter)

# Draw a line
pdf_canvas.setStrokeColorRGB(0.2, 0.5, 0.3)
pdf_canvas.setLineWidth(1)
pdf_canvas.line(100, 750, 500, 750)

# Draw a string of text
text = pdf_canvas.beginText()
text.setTextOrigin(100, 700)
text.setFont("Helvetica", 12)
text.textLine("Hello, world!")
pdf_canvas.drawText(text)

# Draw an image
image = "example_image.png"
pdf_canvas.drawImage(image, 100, 500, width=300, height=200)

# Save the PDF document
pdf_canvas.save()

In this code, we’re using the Canvas object to draw a line, a string of text, and an image. We set the stroke color and line width of the line using the setStrokeColorRGB() and setLineWidth() methods. The beginText() method is used to create a new text object, which is then positioned using the setTextOrigin() method and drawn using the drawText() method. Finally, we use the drawImage() method to draw an image onto the canvas.

Using Paragraphs

In ReportLab, a Paragraph is an object that represents a block of text with a specific font, size, and style. You can think of a Paragraph as a container for text that can be styled and formatted in various ways.

When you create a Paragraph object, you specify the text content and various formatting options such as the font, size, color, alignment, and indentation. The formatting options are specified using a markup language called Rich Text Format (RTF), which is similar to HTML.

Here’s an example of creating a Paragraph object:

from reportlab.lib.pagesizes import letter
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.lib.units import inch
from reportlab.pdfgen.canvas import Canvas
from reportlab.platypus import Paragraph

# Create a canvas object
canvas = Canvas("paragraph.pdf", pagesize=letter)

# Create a paragraph
text = "This is a paragraph created using ReportLab. It supports <b>bold</b>, <i>italic</i>, <u>underline</u>, and even <font color='red'>colorful</font> text!"
style = getSampleStyleSheet()['Normal']
paragraph = Paragraph(text, style)

# Draw the paragraph on the canvas
paragraph.wrapOn(canvas, inch*6, inch*6)
paragraph.drawOn(canvas, inch, inch*6)

# Save the PDF
canvas.save()

In this code, we’re using the ParagraphStyle object to define a style for the paragraph with various formatting options such as the font, size, and alignment. We then create a new Paragraph object with the specified text and style.

Once you’ve created a Paragraph object, you can add it to a Story object or another container object such as a Frame or PageTemplate. The Story object is a container for one or more Paragraph objects, and is typically used to create a multi-page document with different styles and layouts.

Overall, the Paragraph object is a powerful tool for creating styled and formatted text in ReportLab, and is essential for creating professional-looking PDF documents with customized text content.

Using Flowable

A Flowable is a term used in ReportLab to refer to any object that can be added to a PDF document. Examples of Flowable objects include paragraphs, tables, images, and shapes.

The Flowable object provides a draw method that is called when the object is added to the PDF document. This method takes a Canvas object as an argument, and is responsible for drawing the object on the canvas.

Here’s an example of using flowables:

from reportlab.lib.pagesizes import letter
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.lib.units import inch
from reportlab.pdfgen import canvas
from reportlab.platypus import Paragraph, Spacer, Image, Table

# Define the PDF document dimensions
PAGE_WIDTH, PAGE_HEIGHT = letter

# Create a canvas object
c = canvas.Canvas('my_pdf_file.pdf', pagesize=letter)

# Define a sample style sheet
styles = getSampleStyleSheet()

# Create a paragraph flowable
p = Paragraph('Hello, world!', styles['Normal'])

# Create a spacer flowable
spacer = Spacer(1, 0.25*inch)

# Create an image flowable
image = Image('my_image.png', width=2*inch, height=2*inch)

# Create a table flowable
data = [
    ['Name', 'Age', 'Country'],
    ['Alice', '25', 'USA'],
    ['Bob', '30', 'Canada'],
    ['Charlie', '40', 'Australia'],
]
table = Table(data)
# Note: We will cover tables in more detail in next part.

# Add the flowables to the canvas
p.wrapOn(c, PAGE_WIDTH, PAGE_HEIGHT)
p.drawOn(c, 1*inch, 10*inch)

spacer.wrapOn(c, PAGE_WIDTH, PAGE_HEIGHT)
spacer.drawOn(c, 1*inch, 8.5*inch)

image.wrapOn(c, PAGE_WIDTH, PAGE_HEIGHT)
image.drawOn(c, 1*inch, 6*inch)

table.wrapOn(c, PAGE_WIDTH, PAGE_HEIGHT)
table.drawOn(c, 1*inch, 3*inch)

# Save the PDF document
c.save()

In this code, we define several flowables: a paragraph, a spacer, an image, and a table. We then add each flowable to the canvas using the wrapOn and drawOn methods. The wrapOn method calculates the size of the flowable and sets its position on the canvas, while the drawOn method draws the flowable on the canvas.

Finally, we save the PDF document using the save method of the canvas object.

You can customize the appearance and behavior of each flowable by passing arguments to their constructors or using their methods and properties. For example, you can change the font size, color, and alignment of a paragraph, or the position and rotation of an image. For more information on the available flowables and their properties and methods, refer to the ReportLab documentation.

Using Shapes

ReportLab provides support for generating shapes in PDF documents using the reportlab.graphics.shapes module. You can use this module to create lines, rectangles, circles, and other shapes.

Here’s an example that demonstrates how to create a rectangle:

from reportlab.lib.pagesizes import A4
from reportlab.pdfgen.canvas import Canvas
from reportlab.lib.units import cm
from reportlab.lib.colors import red, green, blue
from reportlab.lib.utils import ImageReader
from reportlab.lib import colors
from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_RIGHT
from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
from reportlab.platypus import Paragraph
from reportlab.graphics.shapes import Circle, Drawing, Line, PolyLine, Rect

# Define the canvas object
canvas = Canvas("example_shapes.pdf", pagesize=A4)

# Draw a circle
circle = Circle(5*cm, 20*cm, 3*cm)
circle.fillColor = colors.red
drawing = Drawing()
drawing.add(circle)
drawing.drawOn(canvas, 0, 0)

# Draw a rectangle
rect = Rect(12*cm, 20*cm, 6*cm, 4*cm)
rect.fillColor = colors.green
drawing = Drawing()
drawing.add(rect)
drawing.drawOn(canvas, 0, 0)

# Draw a line
line = Line(3*cm, 10*cm, 15*cm, 10*cm)
line.strokeColor = colors.blue
drawing = Drawing()
drawing.add(line)
drawing.drawOn(canvas, 0, 0)

# Draw a polyline
polyline = PolyLine([(2*cm, 2*cm), (4*cm, 4*cm), (6*cm, 2*cm), (8*cm, 4*cm), (10*cm, 2*cm)])
polyline.strokeColor = colors.blue
drawing = Drawing()
drawing.add(polyline)
drawing.drawOn(canvas, 0, 0)

# Save the PDF document
canvas.save()

This code creates a new PDF document, defines the various shapes available in ReportLab and adds those to the PDF document using a Drawing object.

That brings us to the end of Part 1 of this tutorial. In the next part, we will delve even deeper into the world of ReportLab, exploring more advanced features and techniques. Part 3 will showcase several complex examples that leverage many of the features we’ve discussed thus far, as well as introduce some more advanced ReportLab concepts. We welcome any feedback or suggestions for improvement that you may have, as we strive to provide a comprehensive and accessible guide to ReportLab. So stay tuned, and happy coding!

References:

Create Pdf
Python Pdf
Python
Python Web Development
Pdf Generation

--

--

Praveen Goyal

Written by Praveen Goyal

4 Followers

Help

Status

About

Careers

Blog

Privacy

Terms

Text to speech

Teams