根据 Flask 中请求的内容类型更改响应

Question

I have a Flask application that returns both HTML pages and JSON responses to API requests. I want to change what an error handler returns based on the content type of the request. If the client requests application/json , I want to return a jsonify response, otherwise I want to return a render_template response. How can I detect what was requested and change the response appropriately?

The current error handlers I have only return an HTML response.

def register_errorhandlers(app):
    """Register error handlers."""
    def render_error(error):
        """Render error template."""
        # If a HTTPException, pull the `code` attribute; default to 500
        error_code = getattr(error, 'code', 500)
        return render_template('{0}.html'.format(error_code)), error_code
    for errcode in [401, 404, 500]:
        app.errorhandler(errcode)(render_error)

Answer 1

Use request.content_type to get the content type the client sent with the request. Use request.accept_mimetypes the get the mimetypes the client indicated it can accept in a response. Use these to determine what to return.

from flask import request, jsonify, render_template

if request.accept_mimetypes.accept_json:
    return jsonify(...)
else:
    return render_template(...)

Answer 2

I used the after_request decorator to do this and checked the content type:

@app.after_request
def after_request_helper(resp):
    if resp.content_type == "text/html":
        # If a HTTPException, pull the `code` attribute; default to 500
        error_code = getattr(error, 'code', 500)
        return render_template('{0}.html'.format(error_code)), error_code
    else:
        return app.errorhandler(errcode)(render_error)

Answer 3

A more detailed answer:

def wants_json_response():
    return request.accept_mimetypes['application/json'] >= \
    request.accept_mimetypes['text/html']

The wants_json_response() helper function compares the preference for JSON or HTML selected by the client in their list of preferred formats. If JSON rates higher than HTML, then it is necessary to return a JSON response. Otherwise, return the original HTML responses based on templates.

For the JSON responses would slightly supplement the function with one condition: if wants_json_response(): which is what you need. So the answer is in that.

If the condition is true we could write a function that would generate a response:

def api_error_response(status_code, message=None):
    payload = {'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error')}
    if message:
        payload['message'] = message
    response = jsonify(payload)
    response.status_code = status_code
    return response

This function uses the handy HTTP_STATUS_CODES dictionary from Werkzeug (a core dependency of Flask) that provides a short descriptive name for each HTTP status code. For easier and faster understanding, 'error' is used to represent errors, so you only need to worry about the numeric status code and the optional long description. The jsonify() function returns a Flask Response object with a default status code of 200, so after the response is created, it is necessary to set the status code to the correct one for the error.

So if we put it all together now it would look like this:

# app/__init__.py
import requests

def register_errorhandlers(app):
    from .errors import render_error

    for e in [
        requests.codes.INTERNAL_SERVER_ERROR,
        requests.codes.NOT_FOUND,
        requests.codes.UNAUTHORIZED,
    ]:
        app.errorhandler(e)(render_error)

and

# app/errors.py
import requests

from flask import render_template, request, jsonify
from werkzeug.http import HTTP_STATUS_CODES

from .extensions import db


def api_error_response(status_code, message=None):
    payload = {'error': HTTP_STATUS_CODES.get(status_code, 'Unknown error')}
    if message:
        payload['message'] = message
    response = jsonify(payload)
    response.status_code = status_code
    return response


def wants_json_response():
    return request.accept_mimetypes['application/json'] >= \
    request.accept_mimetypes['text/html']


def render_error(e):
    if requests.codes.INTERNAL_SERVER_ERROR == e.code:
        db.session.rollback()
    if wants_json_response():
        return api_error_response(e.code)
    else:
        return render_template(f'{e.code}.html'), e.code

Additionally

Then they could use the response generation for other cases as well. The most common error that the API is going to return is going to be the code 400, which is the error for “bad request”. This is the error that is used when the client sends a request that has invalid data in it.

In order to generate messages to the function below even easier in these cases, we forward only the required description - message .

def bad_request(message):
    return api_error_response(400, message)

I hope this will help in approaching with errors :)