Minify HTML output from Flask application with Jinja2 templates

To extend the usefulness of the answer from @olly_uk and the comment by @Alexander, it appears that the django-htmlmin extension is now designed to be used with frameworks other than Django.

From the docs here, you can manually use the html_minify function in Flask views, like so:

from flask import Flask
from htmlmin.minify import html_minify

app = Flask(__name__)

@app.route('/')
def home():
    rendered_html = render_template('home.html')
    return html_minify(rendered_html)

Found a better way to do this. You can minify all your pages with this method:

from flask import Flask
from htmlmin.main import minify

app = Flask(__name__)


@app.after_request
def response_minify(response):
    """
    minify html response to decrease site traffic
    """
    if response.content_type == u'text/html; charset=utf-8':
        response.set_data(
            minify(response.get_data(as_text=True))
        )

        return response
    return response

Use the decorator.

from htmlmin.decorator import htmlmin

@htmlmin
def home():
...

Or you can just use:

re.sub(r'>s+<', '><', '<tag>   </tag>') # results '<tag></tag>'

I’ve written a flask extension to achieve that purpose. You can install it using pip install flask-htmlmin and the source is available at https://github.com/hamidfzm/Flask-HTMLmin . Hope it will be useful.

I use the following decorators

import bs4
import functools
import htmlmin


def prettify(route_function):
    @functools.wraps(route_function)
    def wrapped(*args, **kwargs):
        yielded_html = route_function(*args, **kwargs)
        soup = bs4.BeautifulSoup(yielded_html, 'html.parser')
        return soup.prettify()

    return wrapped

def uglify(route_function):
    @functools.wraps(route_function)
    def wrapped(*args, **kwargs):
        yielded_html = route_function(*args, **kwargs)
        minified_html = htmlmin.minify(yielded_html)
        return minified_html

    return wrapped

And simply wrapped the default render_template function like so

if app.debug:
    flask.render_template = prettify(flask.render_template)
else:
    flask.render_template = uglify(flask.render_template)

This has the added benefit of being auto added to the cache, since we don’t actually touch app.route

Modifying @Bletch answer for the latest version of htmlmin.

from flask import Flask
import htmlmin

app = Flask(__name__)

@app.route('/')
def home():
    rendered_html = render_template('home.html')
    return htmlmin.minify(rendered_html)

https://htmlmin.readthedocs.io/en/latest/quickstart.html

The minified html will still have some spaces between the tags. If we want to remove that, then remove_empty_space =True attribute needs to be added while the template is rendered.

return htmlmin.minify(rendered_html, remove_empty_space =True)

https://htmlmin.readthedocs.io/en/latest/reference.html

In 2022, I have found better success using the minify-html package: https://github.com/wilsonzlin/minify-html

minify_html.minify(
    """
    html here
    """,
    minify_js=True, 
    minify_css=True,
    remove_processing_instructions=True,
)