Ricevi i dati ricevuti in una richiesta Flask

Voglio essere in grado di ottenere i dati inviati alla mia app Flask. Ho provato ad accedere request.datama è una stringa vuota. Come si accede ai dati della richiesta?

from flask import request

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

La risposta a questa domanda mi ha portato a chiedere il corpo Get POST raw in Python Flask indipendentemente dall'intestazione Content-Type successiva, che riguarda l'ottenimento dei dati grezzi anziché dei dati analizzati.

I documenti descrivono gli attributi disponibili sulla richiesta. Nella maggior parte dei casi comuni request.datasaranno vuoti perché utilizzati come fallback:

request.data Contiene i dati della richiesta in arrivo come stringa nel caso in cui venisse fornito con un mimetype che Flask non gestisce.

• request.args: le coppie chiave / valore nella stringa di query URL
• request.form: le coppie chiave / valore nel corpo, da un modulo di post HTML o una richiesta JavaScript che non è codificata JSON
• request.files: i file nel corpo da cui Flask si separa form. I moduli HTML devono essere utilizzati enctype=multipart/form-datao i file non verranno caricati.
• request.values: combinato argse form, preferendo argsse le chiavi si sovrappongono
• request.json: dati JSON analizzati. La richiesta deve avere il application/jsontipo di contenuto o utilizzare request.get_json(force=True)per ignorare il tipo di contenuto.

Tutte queste sono MultiDictistanze (eccetto json). Puoi accedere ai valori usando:

• request.form['name']: usa l'indicizzazione se sai che la chiave esiste
• request.form.get('name'): utilizzare getse la chiave potrebbe non esistere
• request.form.getlist('name'): utilizzare getlistse la chiave viene inviata più volte e si desidera un elenco di valori. getrestituisce solo il primo valore.

Per ottenere i dati non elaborati, utilizzare request.data. Funziona solo se non può essere analizzato come dati del modulo, altrimenti sarà vuoto e request.formavrà i dati analizzati.

from flask import request
request.data

Per i parametri della query URL, utilizzare request.args.

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

Per l'input del modulo inviato, utilizzare request.form.

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

Per JSON pubblicato con tipo di contenuto application/json, utilizzare request.get_json().

data = request.get_json()

Ecco un esempio di analisi dei dati JSON pubblicati e di riecheggiarli.

from flask import Flask, request, jsonify

app = Flask(__name__)

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

Per pubblicare JSON con arricciatura:

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

O per usare Postman:

Se pubblichi JSON con il tipo di contenuto application/json, usa request.get_json()per ottenerlo in Flask. Se il tipo di contenuto non è corretto, Noneviene restituito. Se i dati non sono JSON, viene generato un errore.

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

Per ottenere il corpo del post non elaborato indipendentemente dal tipo di contenuto, utilizzare request.get_data(). Se lo usi request.data, chiama request.get_data(parse_form_data=True), che popolerà request.form MultiDicte lascerà datavuoto.

Per ottenere request.formcome un normale dizionario, utilizzare request.form.to_dict(flat=False).

Per restituire i dati JSON per un'API, passali a jsonify.

Questo esempio restituisce i dati del modulo come dati JSON.

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

Ecco un esempio di dati di modulo POST con arricciatura, che ritornano come JSON:

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

Utilizzare request.get_json()per ottenere dati JSON pubblicati.

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

Utilizzare request.formper ottenere dati quando si invia un modulo con il metodo POST.

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

Utilizzare request.argsper ottenere i dati passati nella stringa di query dell'URL, come quando si invia un modulo con il metodo GET.

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

request.formecc. sono simili a dict, utilizzare il getmetodo per ottenere un valore con un valore predefinito se non è stato passato.

Per ottenere JSON pubblicato senza il application/jsontipo di contenuto, utilizzare 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)

I dati non elaborati vengono passati all'applicazione Flask dal server WSGI come request.stream. La lunghezza del flusso è Content-Lengthnell'intestazione.

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

Di solito è più sicuro da usare request.get_data()invece.

Per pubblicare JSON con jQuery in JavaScript, utilizzare JSON.stringifyper scaricare i dati e impostare il tipo di contenuto su 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");
    }   
});

Analizzalo in pallone con request.get_json().

data = request.get_json()

Per analizzare JSON, utilizzare request.get_json().

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

Ecco un esempio di pubblicazione dei dati dei moduli per aggiungere un utente a un database. Verifica request.method == "POST"se il modulo è stato inviato. Utilizzare i tasti da request.formper ottenere i dati del modulo. Renderizza un modello HTML con un <form>altrimenti. I campi nel modulo devono avere nameattributi che corrispondono alle chiavi 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>

Se il tipo di contenuto viene riconosciuto come dati del modulo, request.dataanalizzerà request.forme restituirà una stringa vuota.

Per ottenere i dati non elaborati indipendentemente dal tipo di contenuto, chiama request.get_data(). request.datachiama get_data(parse_form_data=True), mentre l'impostazione predefinita è Falsese la chiami direttamente.

Se il corpo viene riconosciuto come dato del modulo, verrà inserito request.form. Se è JSON, sarà presente request.get_json(). Altrimenti i dati grezzi saranno presenti request.data. Se non sei sicuro di come verranno inviati i dati, puoi utilizzare una orcatena per ottenere il primo con i dati.

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

request.argscontiene argomenti analizzati dalla stringa di query, indipendentemente da ciò che era nel corpo, quindi lo rimuoveresti get_request_data()se sia esso che un corpo dovessero dati contemporaneamente.

Quando pubblichi dati di un modulo con un modulo HTML, assicurati che i inputtag abbiano degli nameattributi, altrimenti non saranno presenti in 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')])

Solo l' txt3input aveva un name, quindi è l'unica chiave presente request.form.