Generic pdf creation tools for Django
Switch branches/tags
Nothing to show
Latest commit faff52d Feb 7, 2012 @ejucovy ejucovy helper method
Failed to load latest commit information.
pdfbuilder helper method Feb 7, 2012
.gitignore initial commit Feb 3, 2012
LICENSE.txt add license Feb 3, 2012 add default css Feb 4, 2012
README.txt give user more control over coverletter Feb 7, 2012 update metadata Feb 3, 2012


django-pdfbuilder builds PDFs from your data.  It provides:

* A Python library for generating PDFs from objects by providing an
  abstraction layer over Reportlab 

* A framework for developing consistent PDF "templates" with fine-grained
  control over layouts, styles, and object-to-PDF rules

* A web application for managing generated PDFs and configuration 


1) pip install django-pdfbuilder

2) Add "pdfbuilder" to your Django project's ``INSTALLED_APPS``

3) Include the provided URLconf in your with a line like ``url(prefix, include("pdfbuilder.urls"))``

4) Configure a data source function in ``settings.PDFBUILDER_DATA_SOURCE``
   (see below)

5) syncdb

6) Register some PDF configuration templates (see below)

Data Sources

A data source is a function that returns a Django queryset which can
be used to generate PDFs.  For example:

  def my_pdf_data_source(request, data_source_key=None):
    return MyModel.objects.all()

The "data_source_key" argument will be a string provided by the end user.
You can use this to provide different subsets of data, or even data from
different models, for different requests.

After you have written a data source function, reference it by dotted name
in your ```` file.  For example, if the above function was placed
in a ``myapp/`` file, you would write:

  PDFBUILDER_DATA_SOURCE = "myapp.pdfbuilder_settings.my_pdf_data_source"

in your ```` file.

Defining available data sources for the end user

By default, when generating a PDF, the end user will be presented with
a simple freeform text input where he can specify the "data_source_key"
that he wants to use.

You can override this user interface element to provide a fixed set of
available data_source keys by overriding the template


with your own HTML.

Cover Letter

The end user can specify a cover letter that will be prepended to the
PDF.  The user should input the cover letter in Markdown format.  It
will be converted to HTML (using the markdown library) and then to a
PDF (using the pisa/xhtml2pdf library) and will then be merged with
the primary output PDF (using the pyPdf library) when that PDF has
been saved.

A pisa CSS stylesheet is used to control the font sizes, margins
and other styling options for the cover letter.  A default stylesheet
is provided in ``pdfbuilder/pisa-default.css`` which is set to use the 
same fonts and margins that are used for the primary output PDF in
the default templates provided.

If you customize the templates you may need to customize the CSS
for the cover letter to ensure that the styles match.  To do this,
fork the provided ``pdfbuilder/pisa-default.css`` file into your project
and spell out the path to it in your project's ```` like::

  PDFBUILDER_COVERLETTER_CSS = "/path/to/your/styles.css"

Note that you will want to fork the provided CSS stylesheet and make
any necessary changes, rather than starting from a fresh stylesheet.
The stylesheet contains some non-standard language and configuration
(defined and consumed by pisa) which is necessary for the pdf output
to work properly.

TODO: make the CSS file be TTW-managed content?

After being converted from markdown to HTML, the cover letter will
be wrapped in a simple HTML wrapper with a <head> to declare UTF8
content type and a <body> into which the cover letter contents
are placed.  You can customize this HTML wrapper by pointing to
will receive the HTML contents of the cover letter, the request,
and the PDF configuration object and should return an HTML string.
The default function is defined in ``pdfbuilder.coverletter`` and
the setting looks like::

  PDFBUILDER_COVERLETTER_FUNCTION = 'pdfbuilder.coverletter.default_coverletter_function'

PDF Grouping Options

PDFs can be "grouped", meaning multiple PDFs will be generated from
the given options.  For example, if you are generating PDFs from
``django.contrib.comments`` objects, you could group comments by
their ``content_object`` properties, and generate a distinct PDF
for each content object that has received comments.

To register a new grouping option::

  from pdfbuilder import registry
  registry.register_grouping(grouping_fn, string_id, text_description)

It will then appear as an option in the PDF configuration form.  You
should do this registration somewhere that will be guaranteed to be
imported early, like an INSTALLED_APP's ````.

Each grouping_fn should be a function with signature ``(buckets, entry)``
that will be called for each model instance from your data source, before
it is used to build an entry in the PDF output.  The ``buckets`` argument
is a stateful dict of lists-of-instances, grouped according to which PDF 
they will be put into.

The job of the grouping_fn is threefold:

 * Figure out what group the given signature belongs to
 * Create an empty list entry in the ``buckets`` dict if the
   appropriate group does not exist 
 * Return the string key of the group that the signature belongs to

This dict will then be used to determine how many distinct PDFs to
create, and which PDF each signature belongs to.  The string keys that
your grouping_fn creates in the ``buckets`` dict will also be used to
identify each distinct PDF to the end user.

Note that at the moment each entry can only be in one bucket.

A default grouping_fn (which groups all entries into a single PDF) and
its registration can be found in ``pdfbuilder/``.

PDF Sort Order Options

To register a new sort order::

  from pdfbuilder import registry
  registry.register_ordering(tuple, string_id, text_description)

It will then appear as an option in the PDF configuration form.  You
should do this registration somewhere that will be guaranteed to be
imported early, like an INSTALLED_APP's ````.

The "tuple" argument should be a tuple of Django `order_by` args, that
is, one or more strings that reference columns on the model you are
pulling data from. For example, if you are generating PDFs from
``django.contrib.comments`` objects, valid sorting registrations would

			     "site", "Order alphabetically by name of associated site")
  registry.register_ordering(('user__last_name', 'user__first_name', 'user_name'),
			     "name", "Order alphabetically by name of commenter")
                             "date", "Order comments from most recent to earliest")

PDF Filter Options

Registering a new filtering option is done simply by overriding the 
template ``pdfbuilder/snippets/configuration_form_filters.html`` and
adding an additional HTML checkbox for the filter you want to add.

The checkbox's value should correspond to a method defined on the
model class of your data source.  This method will be called to
determine whether a given entry should be included or omitted from the
generated PDF.  The entry will be omitted if and only if the specified
method returns ``None``.  (Specifically ``None``, not any false value;
if the method returns an empty string, this will not be sufficient to
omit it.)

So, to add a new filtering option, you may need to add a new method to
your data-source model classes that performs whatever query you want to
filter by.

TODO: register arbitrary filter functions instead

PDF Layout Templates

To register a new template::

  from pdfbuilder import registry
  registry.register_template(TemplateClass, string_id, text_description)

It will then appear as an option in the PDF configuration form.  You
should do this registration somewhere that will be guaranteed to be
imported early, like an INSTALLED_APP's ````.

A set of sample general-purpose templates and their registrations are defined
in ``pdfbuilder/``.  To use these, import them with

  from pdfbuilder import sampletemplates

in your own code.  Alternatively, you can provide your own PDF template classes
and register them instead.

Your PDF template class should be a subclass of
``pdfbuilder.basetemplates.PDFTemplate`` which implements the
``generate_flowable_from_entry`` classmethod.  Basically, this method is called
for each model instance in your data source, and is expected to return a 
ReportLab "flowable" that will be rendered in the PDF document.
(See ``pdfbuilder/`` for examples.)

For most layouts, implementing this method should be sufficient.  You
might need to customize other things though.

Changing the Platypus Doctemplate

By default, PDFTemplates use a subclass of
``reportlab.platypus.SimpleDocTemplate`` to build their PDFs.  This
subclass provides configurable page header and footer functionality.

You can customize the ``reportlab.platypus`` DocTemplate used by your
``PDFTemplate`` by setting a class attribute ``doctemplatefactory``.
See ``pdfbuilder.sampletemplates:ThreeColumnDown`` as an example.
This template uses a non-default doctemplate which defines a
three-column newspaper-style layout.

If you need to customize the initialization of a doctemplate (as well
as its definition) you can override the classmethod
``PDFTemplate.doctemplate`` to provide custom logic.  This method
receives a ``pdfbuilder.models.Configuration`` object which you can use
to determine how to initialize the doctemplate.

Changing the Entry-Numbering Style

Your PDFTemplate subclass can override ``PDFTemplate.entry_prefix`` to
customize the display of entry numbers.  It takes a boolean
``should_number_entries`` argument determined by configuration; you
should make sure to respect this by returning an empty string if it is

Changing the PDF Stylesheet

You can override the ``PDFTemplate.get_stylesheet`` classmethod to return
a custom ReportLab stylesheet for your template.  See the sample templates
in ``pdfbuilder/`` for examples.

Post-Processing the Flowables

You may need to manipulate the list of ReportLab Flowables after they have
been generated but before they are handed off to ReportLab.  To do this,
implement the classmethod ``post_generate_flowables`` on your PDFTemplate 
subclass.  For an example look at ``pdfbuilder.sampletemplates:ThreeColumnAcross``
which implements this method to wrap all flowables in a Reportlab Table flowable.