Export to PDF in Python

ApexCharts by default provides a way to enable users to download individual charts in PNG or SVG by configuring the toolbar. However, when it comes to generating charts on the server, things could become a bit challenging. Especially when your tech stack does not support Node.js. Imagine you want to write a CRON job to send reports with charts in them, allow users to download PDF reports in the realtime or send these reports as an attachment to someone else, this is where server-side chart generation becomes important. We will be learning the same throughout the tutorial. Traditionally when it comes to exporting charts on the server, we use headless browsers like Puppeteer or PhantomJS. But for this tutorial, we will be using FusionExport. Now the obvious question is:

Why FusionExport?

When there is something like Puppeteer or PhantomJS available, why use anything else? Well, you know what happened to PhantomJS – discontinued. Also, both Puppeteer and PhantomJS require you to know or have Node.js infrastructure. On the other hand, FusionExport is a product actively maintained and developed by FusionCharts which also has an SDK for Python. Here are a few reasons why we are using FusionExport:
  1. User-friendly APIs: FusionExport provides excellent APIs focused on exporting charts and dashboards which help you save time as well.
  2. Integrations:¬†It offers SDKs for C#, Java, Node.js, Python, and PHP. So even if your infra doesn’t support Node.js, no need to worry about it!
  3. Support: If you are facing any issues, you can always reach out to their support team and you will get the answer in a matter of a few hours.
  4. Documentation: It provides excellent documentation with examples of real-world scenarios as well.
  5. Stability: FusionCharts actively develops FusionExport, and many enterprises around the world use it.
So, let’s go ahead and start with the installation of FusionExport.

Installation of FusionExport

Installation of FusionExport contains two steps:
  1. Setting up the FusionExport server
  2. Installing the SDKs in your project

Setting up the FusionExport server

Download FusionExport for the choice of your platform. Once you have downloaded it, unzip the package and open the terminal to run the following command:
./fusionexport
If you are using Windows then open PowerShell and run following command:
./fusionexport.bat
If you are using Windows then open PowerShell and run the following command: Console logs after starting the FusionExport server

Installing the Python SDK

Let’s create a Python project called ‘apexcharts-export’.
$ mkdir apexcharts-export
$ cd apexcharts-export
If you are a regular user of environment builder libraries like virtualenv then create the environment before moving to the next command. Now that our directory is created, let’s install Python SDK using pip. In case if you do not have pip installed in your machine, refer to this installation guide.
pip install fusionexport
Now, everything is installed let’s move to the implementation.

Exporting a simple HTML to PDF

Before we go ahead export ApexCharts samples, let’s export a simple HTML snippet to PDF. Create a new file called export_single_chart.py and include the dependencies:
# Import FusionExport SDK client for Python
from fusionexport import ExportManager, ExportConfig

# Instantiate ExportConfig and ExportManager
export_config = ExportConfig()
export_manager = ExportManager()
As you can see above, we have imported two modules from fusionexport and instantiated them:
  1. ExportConfig: This is where you will provide all the configurations to FusionExport like file type, template, etc.
  2. ExportManager: Once you have defined the configurations, you will be passing them to ExportManager, which will further take care of exporting.
Let’s create a simple HTML template and define configurations to export it in the same file:

template = '<html><body><h1>Hello World</h1></body></html>'
export_config['template'] = template
export_config['type'] = 'pdf'
export_config['templateFormat'] = 'A4'
As you can see, we are using three properties to configure:
  1. template: This accepts the HTML template in a string format which you want to export
  2. type: File format in which you want to export. We are using pdf but you can also use jpg, png and svg.
  3. templateFormat: We are setting the page format to A4. There are 7 more formats supported like A3, Letter, etc.
You can check all the available options on FusionExport’s API Reference page Now, let’s export your first page:
export_manager.export(export_config, unzip = True)
As you can see above, we are passing export_config to the export method. By default, your exported file will be present inside a zip, hence we set the unzip flag to True so that it will not be zipped. Your final code will like:

# Import FusionExport SDK client for Python
from fusionexport import ExportManager, ExportConfig

# Instantiate ExportConfig and ExportManager
export_config = ExportConfig()
export_manager = ExportManager()

# Set all the configurations
template = '<html><body><h1>Hello World</h1></body></html>'
export_config['template'] = template
export_config['type'] = 'pdf'
export_config['templateFormat'] = 'A4'

# Export your first PDF
export_manager.export(export_config, unzip = True)
Let’s run this code If the code is executed successfully, it will create a file called export.pdf in the same environment. If you open it, then you will get output similar to this in an A4 page format: Output after exporting your HTML to PDF

Exporting ApexCharts to PDF

Now that we know how to export a simple HTML file let’s learn how to export ApexCharts. There are three important steps to perform this:
  1. Write an HTML template with JavaScript: Unlike earlier examples, we will be writing not just the HTML but also the JavaScript in the template, which will render the chart.
  2. Set up the configurations: As mentioned, we will be providing the configurations with the template to FusionExport
  3. Export!
Let’s create a simple HTML called template.html which will have the ApexCharts code as well.

<html>
  <body>
      <h1>ApexCharts Demo with FusionExport</h1>
      <div id="chart"></div>
      <script src="https://cdn.jsdelivr.net/npm/apexcharts"></script>
      <script>
          var options = {
              chart: { type: 'line' },
              series: [{
                  name: 'sales',
                  data: [30,40,35,50,49,60,70,91,125]
              }],
              xaxis: {
                  categories: [1991,1992,1993,1994,1995,1996,1997,1998,1999]
              }
          }

          var chart = new ApexCharts(document.querySelector("#chart"), options);

          chart.render();
      </script>
  </body>
</html>   
There are a few things happening in the code:
  1. We have added ApexCharts library from CDN
  2. We are rendering a simple line chart in the script tag
  3. Since we won’t be rendering it as a webpage in the browser, we have skipped head and meta tags as well.
If you open this file in a browser, you will find a line chart being rendering with a header on the top. We will be passing this FusionExport with similar configurations mentioned earlier. Behind the scene, FusionExport also comes with a headless browser that will take this template and render it in the headless browser. After this, it will apply various options provided via the configuration, followed by generating the final exported file. Now, let’s get back to the export_single_chart.py, and following code snippet to read the HTML template and pass it to FusionExport:

# Fetch file path of the template
curr_dir = os.path.dirname(os.path.abspath(__file__))
template_path = os.path.join(curr_dir, 'template.html')

# Set all the configurations
export_config['templateFilePath'] = template_path
export_config['type'] = 'pdf'
export_config['templateFormat'] = 'A4'
export_config['asyncCapture'] = True
In the above snippet, we are doing the following things:
  1. Replaced template with templateFilePath where we are reading the HTML file made earlier. We are using the os module to read the path of HTML template
  2. We have kept rest of the configurations same
  3. We have added a property called asyncCapture which waits till the charts are loaded. It is extremely handy when you have charts with animations.
Your final code should look like this:

# Import FusionExport SDK client for Python
from fusionexport import ExportManager, ExportConfig
import os

# Instantiate ExportConfig and ExportManager
export_config = ExportConfig()
export_manager = ExportManager()

# Fetch the curr directory of the template
curr_dir = os.path.dirname(os.path.abspath(__file__))
template_path = os.path.join(curr_dir, 'template.html')

# Set all the configurations
export_config['templateFilePath'] = template_path
export_config['type'] = 'pdf'
export_config['templateFormat'] = 'A4'
export_config['asyncCapture'] = True

# Export your first PDF
export_manager.export(export_config, unzip = True)
Once you try to export, the final export will look like this: Output of the exported PDF with ApexCharts  

Making it pretty

Now that you have exported your first chart. Let’s make it pretty by adding some styles:

body {
    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
    padding: 1em;
}
h1 { text-align: center; }
#chart { margin-top: 1em; }
We will be adding the above code snippet in the head. In the above code, we are doing the following things:
  1. Replaced the default serif font with system font which means in case of latest macOS, you will see San Fransisco
  2. We have added padding across the page
  3. Made the header center-aligned and added some margin between header and chart
Also, let’s remove the hamburger menu from the chart because it is completely irrelevant in this case.
chart: {
	type: 'line',
	toolbar: { tools: { download: false } }
}
Once, everything is done your file will look like this: Output of the exported PDF with ApexCharts and additional CSS That’s all folks. This is how you export a single chart made in ApexCharts on the server. Feel free to download the source code on Github. If you have any feedback or found any issues, submit an issue on the repository.

What’s next?

Now that you know how to export a single chart, you can similarly add more charts in the PDF. You can even add your CSS to customize the look. Furthermore, you can use a similar way to write CRON jobs to send emails with PDF attachments or even allow users to download dashboards in realtime. For more such demos check our dashboards built with ApexCharts and FusionExport.