I have a function that analyzes a CSV file with Pandas and produces a dict with summary information. I want to return the results as a response from a Flask view. How do I return a JSON response?
@app.route("/summary")
def summary():
d = make_summary()
# send it back as json
In Flask 1.1, if you return a dictionary and it will automatically be converted into JSON. So if make_summary()
returns a dictionary, you can
from flask import Flask
app = Flask(__name__)
@app.route('/summary')
def summary():
d = make_summary()
return d
The SO that asks about including the status code was closed as a duplicate to this one. So to also answer that question, you can include the status code by returning a tuple of the form (dict, int)
. The dict
is converted to JSON and the int
will be the HTTP Status Code. Without any input, the Status is the default 200. So in the above example the code would be 200. In the example below it is changed to 201.
from flask import Flask
app = Flask(__name__)
@app.route('/summary')
def summary():
d = make_summary()
return d, 201 # 200 is the default
You can check the status code using
curl --request GET "http://127.0.0.1:5000/summary" -w "\ncode: %{http_code}\n\n"
If you don't want to use jsonify
for some reason, you can do what it does manually. Call flask.json.dumps
to create JSON data, then return a response with the application/json
content type.
from flask import json
@app.route('/summary')
def summary():
data = make_summary()
response = app.response_class(
response=json.dumps(data),
mimetype='application/json'
)
return response
flask.json
is distinct from the built-in json
module. It will use the faster simplejson
module if available, and enables various integrations with your Flask app.
""" Using Flask Class-base View """
from flask import Flask, request, jsonify
from flask.views import MethodView
app = Flask(**__name__**)
app.add_url_rule('/summary/', view_func=Summary.as_view('summary'))
class Summary(MethodView):
def __init__(self):
self.response = dict()
def get(self):
self.response['summary'] = make_summary() # make_summary is a method to calculate the summary.
return jsonify(self.response)
As of version 1.1.0 Flask, if a view returns a dict it will be turned into a JSON response.
@app.route("/users", methods=['GET'])
def get_user():
return {
"user": "John Doe",
}
Pass keyword arguments to flask.jsonify
and they will be output as a JSON object.
@app.route('/_get_current_user')
def get_current_user():
return jsonify(
username=g.user.username,
email=g.user.email,
id=g.user.id
)
{
"username": "admin",
"email": "admin@localhost",
"id": 42
}
If you already have a dict, you can pass it directly as jsonify(d)
.
if its a dict, flask can return it directly (Version 1.0.2)
def summary():
d = make_summary()
return d, 200
I use a decorator to return the result of jsonfiy
. I think it is more readable when a view has multiple returns. This does not support returning a tuple like content, status
, but I handle returning error statuses with app.errorhandler
instead.
import functools
from flask import jsonify
def return_json(f):
@functools.wraps(f)
def inner(**kwargs):
return jsonify(f(**kwargs))
return inner
@app.route('/test/<arg>')
@return_json
def test(arg):
if arg == 'list':
return [1, 2, 3]
elif arg == 'dict':
return {'a': 1, 'b': 2}
elif arg == 'bool':
return True
return 'none of them'
I like this way:
@app.route("/summary")
def summary():
responseBody = { "message": "bla bla bla", "summary": make_summary() }
return make_response(jsonify(responseBody), 200)
jsonify
serializes the data you pass it to JSON. If you want to serialize the data yourself, do what jsonify
does by building a response with status=200
and mimetype='application/json'
.
from flask import json
@app.route('/summary')
def summary():
data = make_summary()
response = app.response_class(
response=json.dumps(data),
status=200,
mimetype='application/json'
)
return response
To return a JSON response and set a status code you can use make_response
:
from flask import jsonify, make_response
@app.route('/summary')
def summary():
d = make_summary()
return make_response(jsonify(d), 200)
Inspiration taken from this comment in the Flask issue tracker.
Flask 1.1.x supports returning a JSON dict without calling jsonify
. If you want to return something besides a dict, you still need to call jsonify
.
@app.route("/")
def index():
return {
"api_stuff": "values",
}
is equivalent to
@app.route("/")
def index():
return jsonify({
"api_stuff": "values",
})
See the pull request that added this: https://github.com/pallets/flask/pull/3111
If you want to analyze a file uploaded by the user, the Flask quickstart shows how to get files from users and access them. Get the file from request.files
and pass it to the summary function.
from flask import request, jsonify
from werkzeug import secure_filename
@app.route('/summary', methods=['GET', 'POST'])
def summary():
if request.method == 'POST':
csv = request.files['data']
return jsonify(
summary=make_summary(csv),
csv_name=secure_filename(csv.filename)
)
return render_template('submit_data.html')
Replace the 'data'
key for request.files
with the name of the file input in your HTML form.
Create a python dictionary to return as the response:
response = {'key': 'value'}
Then you can use json.dumps() or flask.jsonify() to turn a python dictionary into JSON:
from json import dumps
return dumps(response)
from flask import jsonify
return jsonify(response)
Note that flask.jsonify() is made for flask and also it has some more advatages. You can use it like in the following code:
from flask import jsonify
params = {
'key': 'value'
}
return jsonify(**params)
This is like using the following line:
return jsonify(key='value')
Remeber in this code you don't need the response dictionary!
Prior to Flask 0.11, jsonfiy
would not allow returning an array directly. Instead, pass the list as a keyword argument.
@app.route('/get_records')
def get_records():
results = [
{
"rec_create_date": "12 Jun 2016",
"rec_dietary_info": "nothing",
"rec_dob": "01 Apr 1988",
"rec_first_name": "New",
"rec_last_name": "Guy",
},
{
"rec_create_date": "1 Apr 2016",
"rec_dietary_info": "Nut allergy",
"rec_dob": "01 Feb 1988",
"rec_first_name": "Old",
"rec_last_name": "Guy",
},
]
return jsonify(results=list)
Source: Stackoverflow.com