Obtenez les données reçues dans une demande Flask

Je veux pouvoir envoyer les données à mon application Flask. J'ai essayé d'accéder request.datamais c'est une chaîne vide. Comment accédez-vous aux données de demande?

from flask import request

@app.route('/', methods=['GET', 'POST'])
def parse_request():
    data = request.data  # data is empty
    # need posted data here

La réponse à cette question m'a amené à demander Get corps brut POST dans Python Flask indépendamment de l'en-tête Content-Type suivant, qui consiste à obtenir les données brutes plutôt que les données analysées.

Les documents décrivent les attributs disponibles sur la demande. Dans la plupart des cas, request.datail sera vide car il est utilisé comme solution de rechange:

request.data Contient les données de demande entrantes sous forme de chaîne au cas où elles seraient fournies avec un flacon de type mimetype non géré.

• request.args: les paires clé / valeur dans la chaîne de requête URL
• request.form: les paires clé / valeur dans le corps, à partir d'un formulaire de publication HTML ou d'une requête JavaScript non codée JSON
• request.files: les fichiers dans le corps, dont Flask se sépare form. Les formulaires HTML doivent utiliser enctype=multipart/form-dataou les fichiers ne seront pas téléchargés.
• request.values: combiné argset form, préférant argssi les clés se chevauchent
• request.json: données JSON analysées. La demande doit avoir le application/jsontype de contenu ou utiliser request.get_json(force=True)pour ignorer le type de contenu.

Tous ces éléments sont des MultiDictinstances (à l'exception de json). Vous pouvez accéder aux valeurs en utilisant:

• request.form['name']: utilisez l'indexation si vous savez que la clé existe
• request.form.get('name'): utiliser getsi la clé n'existe pas
• request.form.getlist('name'): à utiliser getlistsi la clé est envoyée plusieurs fois et que vous souhaitez une liste de valeurs. getrenvoie uniquement la première valeur.

Pour obtenir les données brutes, utilisez request.data. Cela ne fonctionne que s'il ne peut pas être analysé en tant que données de formulaire, sinon il sera vide et request.formcontiendra les données analysées.

from flask import request
request.data

Pour les paramètres de requête d'URL, utilisez request.args.

search = request.args.get("search")
page = request.args.get("page")

Pour la saisie de formulaire publiée, utilisez request.form.

email = request.form.get('email')
password = request.form.get('password')

Pour JSON publié avec un type de contenu application/json, utilisez request.get_json().

data = request.get_json()

Voici un exemple d'analyse des données JSON publiées et de leur retour.

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/foo', methods=['POST']) 
def foo():
    data = request.json
    return jsonify(data)

Pour publier du JSON avec curl:

curl -i -H "Content-Type: application/json" -X POST -d '{"userId":"1", "username": "fizz bizz"}' http://localhost:5000/foo

Ou pour utiliser Postman:

Si vous publiez du JSON avec un type de contenu application/json, utilisez-le request.get_json()pour l'obtenir dans Flask. Si le type de contenu n'est pas correct, Noneest renvoyé. Si les données ne sont pas JSON, une erreur est générée.

@app.route("/something", methods=["POST"])
def do_something():
    data = request.get_json()

Pour obtenir le corps brut de la publication, quel que soit le type de contenu, utilisez request.get_data(). Si vous utilisez request.data, il appelle request.get_data(parse_form_data=True), ce qui remplira request.form MultiDictet laissera datavide.

Pour obtenir request.formun dictionnaire normal, utilisez request.form.to_dict(flat=False).

Pour renvoyer des données JSON pour une API, transmettez-les à jsonify.

Cet exemple renvoie des données de formulaire en tant que données JSON.

@app.route('/form_to_json', methods=['POST'])
def form_to_json():
    data = request.form.to_dict(flat=False)
    return jsonify(data)

Voici un exemple de données de formulaire POST avec curl, renvoyant au format JSON:

$ curl http://127.0.0.1:5000/data -d "name=ivanleoncz&role=Software Developer"
{
  "name": "ivanleoncz", 
  "role": "Software Developer"
}

Utilisez request.get_json()pour obtenir des données JSON publiées.

data = request.get_json()
name = data.get('name', '')

Permet request.formd'obtenir des données lors de la soumission d'un formulaire avec la méthode POST.

name = request.form.get('name', '')

Utilisez request.argspour obtenir les données transmises dans la chaîne de requête de l'URL, comme lors de la soumission d'un formulaire avec la méthode GET.

request.args.get("name", "")

request.formetc. sont de type dict, utilisez la getméthode pour obtenir une valeur avec une valeur par défaut si elle n'a pas été transmise.

Pour que JSON soit publié sans le application/jsontype de contenu, utilisez request.get_json(force=True).

@app.route('/process_data', methods=['POST'])
def process_data():
    req_data = request.get_json(force=True)
    language = req_data['language']
    return 'The language value is: {}'.format(language)

Les données brutes sont transmises à l'application Flask à partir du serveur WSGI en tant que request.stream. La longueur du flux est dans l'en- Content-Lengthtête.

length = request.headers["Content-Length"]
data = request.stream.read(length)

Il est généralement plus sûr d'utiliser à la request.get_data()place.

Pour publier JSON avec jQuery en JavaScript, utilisez JSON.stringifypour vider les données et définissez le type de contenu sur application/json.

var value_data = [1, 2, 3, 4];

$.ajax({
    type: 'POST',
    url: '/process',
    data: JSON.stringify(value_data),
    contentType: 'application/json',
    success: function (response_data) {
        alert("success");
    }   
});

Analyser dans Flask avec request.get_json().

data = request.get_json()

Pour analyser JSON, utilisez request.get_json().

@app.route("/something", methods=["POST"])
def do_something():
    result = handle(request.get_json())
    return jsonify(data=result)

Voici un exemple de publication de données de formulaire pour ajouter un utilisateur à une base de données. Cochez request.method == "POST"pour vérifier si le formulaire a été envoyé. Utilisez les touches de request.formpour obtenir les données du formulaire. Rendre un modèle HTML avec un <form>sinon. Les champs du formulaire doivent avoir des nameattributs qui correspondent aux clés request.form.

from flask import Flask, request, render_template

app = Flask(__name__)

@app.route("/user/add", methods=["GET", "POST"])
def add_user():
    if request.method == "POST":
        user = User(
            username=request.form["username"],
            email=request.form["email"],
        )
        db.session.add(user)
        db.session.commit()
        return redirect(url_for("index"))

    return render_template("add_user.html")

<form method="post">
    <label for="username">Username</label>
    <input type="text" name="username" id="username">
    <label for="email">Email</label>
    <input type="email" name="email" id="email">
    <input type="submit">
</form>

Si le type de contenu est reconnu en tant que données de formulaire, request.datal'analysera enrequest.form et renverra une chaîne vide.

Pour obtenir les données brutes quel que soit le type de contenu, appelez request.get_data() . request.dataappels get_data(parse_form_data=True), tandis que la valeur par défaut est Falsesi vous l'appelez directement.

Si le corps est reconnu en tant que donnée de formulaire, il le sera request.form. Si c'est JSON, ce sera dedans request.get_json(). Sinon, les données brutes seront entrées request.data. Si vous n'êtes pas sûr de la façon dont les données seront soumises, vous pouvez utiliser une orchaîne pour obtenir la première avec des données.

def get_request_data():
    return (
        request.args
        or request.form
        or request.get_json(force=True, silent=True)
        or request.data
    )

request.argscontient des arguments analysés à partir de la chaîne de requête, quel que soit le contenu du corps, vous devez donc le supprimer get_request_data()si lui et un corps doivent contenir des données en même temps.

Lorsque vous publiez des données de formulaire avec un formulaire HTML, assurez-vous que les inputbalises ont des nameattributs, sinon ils ne seront pas présents dans request.form.

@app.route('/', methods=['GET', 'POST'])
def index():
    print(request.form)
    return """
<form method="post">
    <input type="text">
    <input type="text" id="txt2">
    <input type="text" name="txt3" id="txt3">  
    <input type="submit">
</form>
"""

ImmutableMultiDict([('txt3', 'text 3')])

Seule l' txt3entrée avait un name, c'est donc la seule clé présente request.form.