Late rendering of text with Jinja integration

[bux-derek]

Hi, I'm trying to determine if I can use FPDF2 for my use case where we need to generate PDF reports with a recurring structure.

Currently we use HTML templates that we convert to PDF using pdfkit. We have different HTML templates that we maintain for different languages, which need to be personalised with some data. The process looks like this:

• select HTML template based on language
• render placeholders in HTML with jinja by injecting a dict with personal data
• convert rendered HTML to PDF

I was wondering if we could use FPDF2 to simplify this process. I thought I could create a report builder class (which has FPDF2 as a subclass) that has pre-defined methods that we can use as building blocks to build up reports, and skip the HTML generation completely. I've managed to do create a POC, but the problem I'm facing now is that the personal data needs to be fed into each FPDF method.

Example:

class ReportBuilder(FPDF):

    def __init__(self, personal_data_dict):

        super().__init__()

        self.PAGE_TITLE_FONT_SIZE = 16
        self.TABLE_TITLE_FONT_SIZE = 12
        self.DEFAULT_FONT_SIZE = 9
        
        self.personal_data_dict = personal_data_dict

    def render_text(self, text):
        return text.format(**self.personal_data_dict)
        
    def new_page(self, title=None, include_info_header=True):
        
        self.add_page(format="A4")
        self.set_margin(15)

        if title:
            self.set_font('Helvetica', size=self.PAGE_TITLE_FONT_SIZE)
            self.cell(h=self.DEFAULT_FONT_SIZE, text=self.render_text(title), markdown=True)
            self.ln(self.DEFAULT_FONT_SIZE / 2)
            self.set_line_width(0.5)
            self.set_draw_color(r=255, g=60, b=100)
            self.line(15, 25, 195, 25)
            self.ln(self.DEFAULT_FONT_SIZE / 2)

        self.set_font_size(self.DEFAULT_FONT_SIZE)
        
        if include_info_header:
            
            with self.table(
                first_row_as_headings=False, 
                line_height=5, 
                markdown=True, 
                borders_layout="NONE",
                col_widths=(70, 30)
            ) as table:
                row = table.row()
                row.cell(img='company-logo.png', padding=(10, 80, 5, 0))
                row.cell(text='**Company**' + '\n' + 'Address' + '\n' + 'Postal code' + '\n' + 'Country', rowspan=2, align='L')
                
                row = table.row()
                row.cell(text=self.render_text('{full_name}\n{address}\n{postal_code}\n{city}, {country_cd}\n{account_number}'))

        return self

    def add_paragraph(self, text, title=None):
    
        self.set_font('Maison Neue', size=self.DEFAULT_FONT_SIZE)
        
        if title:
            self.cell(h=5, text=f"--{self.render_text(title)}--", markdown=True)
            self.ln()

        self.multi_cell(w=180, h=5, align='J', text=self.render_text(text))
        self.ln()
    
        return self

which can be called then as:

personal_data_dict = {
    'first_name': 'John',
    'full_name': 'John Doe',
    'address': 'Wallstreet 1',
    'postal_code': '111111',
    'city': 'Faketown',
    'country_cd': 'US',
    'account_number': 'XXXX-11-AA',
    'report_year': '2024'
}

pdf = (
    ReportBuilder(personal_data_dict)
    .new_page(title="My Report {report_year} - Page 1", include_info_header=True)
    .add_paragraph(text="Hi {first_name},")
    .add_paragraph(text="Below you'll find your {report_year} report. This income tax for {report_year}.")
    .add_paragraph(title='Heading 1', text="Some text 1")
    .add_paragraph(title='Heading 2', text="Some text 2")

    .new_page(title="My Report {report_year} - Page 2", include_info_header=True)
    .add_paragraph(title='Heading 1', text="Some text 1")
    .add_paragraph(title='Heading 2', text="Some text 2")
)

Ideally I render the placeholders text after defining the pdf object (e.g. by calling a render method or something, so that i can use it as a template. Is something like this possible, or do you have ideas how to use the FPDF2 class as a template? I looked at the Templates class as well, but this is not really what i'm looking for.

I'm open for any other direction that could lead to a similar result as well.

[Lucas-C]

Hi @bux-derek and thank you for reaching out 🙂

First of, as stated in our documentation, fpdf2 has limited support regarding HTML specifications.
If you want to stick to HTML templates, you may want to consider using Weasyprint instead, which is very performant to perform HTML to PDF conversion, and very simple to use.

Also, regarding Jinja templating, have you checked our related documentation page for a some usage example ? -> https://py-pdf.github.io/fpdf2/TemplatingWithJinja.html

Apart from that, your ReportBuilder seems fine, and would allow to avoid using HTML templates 🙂

[andersonhc]

If you want to avoid calling render_text() everywhere, you can do something like this in your ReportBuilder class:

    def cell(self, *args, **kwargs):
        text_value = kwargs.pop("text", None)
        if text_value:
            kwargs["text"] = text_value.format(**self.personal_data_dict)
        return super().cell(*args, **kwargs)

    def multi_cell(self, *args, **kwargs):
        text_value = kwargs.pop("text", None)
        if text_value:
            kwargs["text"] = text_value.format(**self.personal_data_dict)
        return super().multi_cell(*args, **kwargs)

[gmischler]

@bux-derek , have you looked at fpdf2s Template() and/or FlexTemplate() helper classes?
They seem to pretty much cover exactly the functionality that you previously implemented with the Jinja/pdfkit combo.

You can prepare different CSV files for different languages, and prepopulate the static text strings in those.
Then you just feed the personalized items into the template, call render() on it and you're done.

You need to figure out which template type best suits your needs.
If you have graphical elements on each page, which you don't want to include in each language specific file, then FlexTemplate() might serve you better. You can create one for the layout elements, one for the language specific text, and maybe even another one for the personalized text, and then just render them all on top of each other.
If you just have pages with a very simple layout of (almost) only text, then the traditional Template() may be simpler to use.