How to create PDF files in a Python/Django application using ReportLab

转载

mb5fca0b6a49e47 2018-05-14 15:11:00

文章标签 sed django python ide 3d 文章分类 代码人生

Web Developer at ASSIST

„Nothing is too small to know and nothing too big to attempt.” - William Cornelius Van Horne

Introduction

Nowadays many web applications have the possibility to save and display data in a portable format. In Python/Django applications we have the possibility to display data in a web page, but also save it in such a format. Official Django documentation contains a basic tutorial about saving data in PDF (Portable Document Format).

First of all, in order to use this library you need to install it. You can install it using pip or easy_install by typing: pip install reportlab or easy_install reportab in your virtual environment. It's fully recommended to use a virtual environment for each of your projects especially if you work on many projects and each of them use different versions of libraries. For example in this application, which is also available on GitHub, we use these libraries:

Django==1.8.2
Pillow==2.8.2
reportlab==3.2.0

In a previous article, the main subject was How to export excel files in a Python/Django application, whereas this article will show you how to export PDF files. This application will extend the one in the previous article; as a recap, the application saves weather data for multiple towns. A user can add different data for weather using the administration interface provided by Django. The home page of application displays today's weather for different towns. The main menu also contains a link to the list of all towns and a link to weather history, which is a page where the user can filter weather history by town and can generate both Excel or PDF files reports.

How to serve the file for download

In order to download the data written in a file format, we can use two buttons on the HTML page, one for Excel and one for PDF. Each of the buttons have an associated na

1	`<button` `class``=``"btn btn-default pull-right"` `name=``"pdf"` `type=``"submit"``></button>`

Forwarding in the corresponding view we have to check if the button name exists in the request. If it does then we create a HttpResponse object with the corresponding content. Afterwards we have to set the content_type to be “application/pdf”, the Content-Disposition to be an attachment, add a name for filename and the corresponding file type, in our case PDF. This will tell the browser to treat this HttpResponse object as an attachment of pdf type.

1 2 3 4 5 6 7 8 9 10	`if` `'pdf'` `in request.POST:` `response = HttpResponse(content_type=``'application/pdf'``)` `today = date.today()` `filename =` `'pdf_demo'` `+ today.strftime(``'%Y-%m-%d'``)` `response[``'Content-Disposition'``] =` `'attachement; filename={0}.pdf'``.format(filename)` `buffer = BytesIO()` `report = PdfPrint(buffer,` `'A4'``)` `pdf = report.report(weather_period,` `'Weather statistics data'``)` `response.write(pdf)` `return` `response`

We use a buffer which contains the PDF data. For this we can use BytesIO class that represents a stream implementation using an in-memory bytes buffer. For the filename we created a filename variable by joining a string and current date.

How to create a PDF document

In order to be as modular as possible we’ve created a class named PdfPrint that contains several methods for creating different elements. This class has an __init__ method with two parameters: buffer and pagesize. Buffer is used to hold data and pagesize is used to set page type and it's width and height. ReportLab has a series of build-in types: A0 to A6, B0 to B6 and letter type, A4 being the default format if we don't give one. Also you have the possibility to set your own page size by providing custom height and width.

1 2 3 4 5 6 7 8	`def __init__(self, buffer, pageSize):` `self.buffer = buffer` `#` `default` `format is A4` `if` `pageSize ==` `'A4'``:` `self.pageSize = A4` `elif pageSize ==` `'Letter'``:` `self.pageSize = letter` `self.width, self.height = self.pageSize`

The lowest level interface used to generate PDF files is Canvas. Canvas can be seen as a white paper where you can “draw” elements like text, images or other graphics elements.

In order to create more complex documents we need to use Platypus (Page Layout and Typography Using Scripts), a high level layout library of ReportLab. Platypus has several layers: DocTemplates, PageTemplates, Frames, Flowables and Canvas. DocTemplates and PageTemplates are used to set document specifications layout. Flowables it is used to wrap, draw or split text or graphics elements in the document. Main flowables used to draw text elements are Paragraph, Spacer and Table. In the next parts of this article we will try to explain how to add such elements in a PDF file.

For the PDF template pages we used SimpleDocTemplate class, a special case document template that can handle multiple simple documents. The code presented bellow is used to set document characteristics (set the margins and the page size). After setting document characteristics, we've created a list used to add flowable elements. At

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18	`def report(self, weather_history, title):` `# set some characteristics` `for` `pdf document` `doc = SimpleDocTemplate(` `self.buffer,` `rightMargin=``72``,` `leftMargin=``72``,` `topMargin=``30``,` `bottomMargin=``72``,` `pagesize=self.pageSize)` `styles = getSampleStyleSheet()` `# create document` `data = []` `data.append(Paragraph(title, styles[``'Title'``]))` `# create other flowables` `doc.build(data)` `pdf = self.buffer.getvalue()` `self.buffer.close()` `return` `pdf`

How to add paragraphs and spaces in between

This section shows you how to add some paragraphs to the document. In order to do this we first need to use a certain style for the paragraph. ReportLab library comes with a set of predefined styles such as: Title, Heading1 to Heading6, Italic, Normal, etc. In order to use these styles we need to use this function getSampleStyleSheet:

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。