Obter os dados recebidos em uma solicitação do Flask

Quero poder enviar os dados para o meu aplicativo Flask. Eu tentei acessar, request.datamas é uma string vazia. Como você acessa os dados da solicitação?

from flask import request

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

A resposta a esta pergunta me levou a perguntar: Obter o corpo bruto do POST no Python Flask, independentemente do cabeçalho Content-Type a seguir, que consiste em obter os dados brutos em vez dos dados analisados.

Os documentos descrevem os atributos disponíveis na solicitação. Nos casos mais comuns, request.dataestará vazio porque é usado como substituto:

request.data Contém os dados da solicitação de entrada como sequência, caso tenham sido fornecidos com um tipo MIME que o Flask não manipula.

• request.args: os pares chave / valor na string de consulta da URL
• request.form: os pares chave / valor no corpo, de um formulário de postagem em HTML ou solicitação de JavaScript que não é codificado em JSON
• request.files: os arquivos no corpo, dos quais o Flask mantém separado form. Os formulários HTML devem ser usados enctype=multipart/form-dataou os arquivos não serão carregados.
• request.values: combinado argse form, preferindo argsse as chaves se sobrepõem
• request.json: analisou dados JSON. A solicitação deve ter o application/jsontipo de conteúdo ou usar request.get_json(force=True)para ignorar o tipo de conteúdo.

Todos esses são MultiDictexemplos (exceto json). Você pode acessar valores usando:

• request.form['name']: use a indexação se você souber que a chave existe
• request.form.get('name'): use getse a chave não existir
• request.form.getlist('name'): use getlistse a chave for enviada várias vezes e você desejar uma lista de valores. getretorna apenas o primeiro valor.

Para obter os dados brutos, use request.data. Isso funciona apenas se não puder ser analisado como dados do formulário; caso contrário, ele estará vazio e request.formterá os dados analisados.

from flask import request
request.data

Para parâmetros de consulta de URL, use request.args.

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

Para entrada de formulário publicado, use request.form.

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

Para JSON publicado com o tipo de conteúdo application/json, use request.get_json().

data = request.get_json()

Aqui está um exemplo de análise de dados JSON postados e repetição.

from flask import Flask, request, jsonify

app = Flask(__name__)

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

Para postar JSON com curl:

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

Ou, para usar o Postman:

Se você postar JSON com o tipo de conteúdo application/json, use-o request.get_json()para obtê-lo no Flask. Se o tipo de conteúdo não estiver correto, Noneserá retornado. Se os dados não forem JSON, um erro será gerado.

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

Para obter o corpo da postagem não processada, independentemente do tipo de conteúdo, use request.get_data(). Se você usar request.data, ele chama request.get_data(parse_form_data=True), que preencherá o request.form MultiDicte ficará datavazio.

Para obter request.formcomo um dicionário normal, userequest.form.to_dict(flat=False) .

Para retornar dados JSON para uma API, passe-os para jsonify .

Este exemplo retorna dados do formulário como dados JSON.

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

Aqui está um exemplo de dados de formulário POST com curl, retornando como JSON:

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

Use request.get_json()para obter dados JSON publicados.

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

Use request.formpara obter dados ao enviar um formulário com o método POST.

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

Use request.argspara obter dados passados ​​na cadeia de consulta da URL, como ao enviar um formulário com o método GET.

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

request.formetc., como ditado, use o getmétodo para obter um valor com um padrão se não foi passado.

Para obter JSON publicado sem o application/jsontipo de conteúdo, use 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)

Os dados brutos são passados ​​para o aplicativo Flask a partir do servidor WSGI como request.stream. O comprimento do fluxo está no Content-Lengthcabeçalho.

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

Geralmente, é mais seguro usá-lo request.get_data().

Para postar JSON com jQuery em JavaScript, use JSON.stringifypara despejar os dados e defina o tipo de conteúdo como 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");
    }   
});

Analise-o no Flask com request.get_json().

data = request.get_json()

Para analisar o JSON, use request.get_json().

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

Aqui está um exemplo de postagem de dados de formulário para adicionar um usuário a um banco de dados. Marque request.method == "POST"para verificar se o formulário foi enviado. Use as teclas de request.formpara obter os dados do formulário. Renderize um modelo HTML de <form>outra forma. Os campos no formulário devem ter nameatributos que correspondam às chaves 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 o tipo de conteúdo for reconhecido como dados do formulário, ele request.dataserá analisado emrequest.form e retornado uma sequência vazia.

Para obter os dados brutos, independentemente do tipo de conteúdo, ligue request.get_data(). request.datachama get_data(parse_form_data=True), enquanto o padrão é Falsese você chamá-lo diretamente.

Se o corpo é reconhecido como dados de formulários, será no request.form. Se é JSON, será no request.get_json(). Caso contrário, os dados em bruto será em request.data. Se você não tiver certeza de como os dados serão enviados, use uma orcadeia para obter a primeira com os dados.

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

request.argscontém args analisados ​​a partir da string de consulta, independentemente do que estava no corpo, portanto, você o removeria get_request_data()se ambos, ele e um corpo, tivessem dados ao mesmo tempo.

Ao postar dados de formulário com um formulário HTML, verifique se as inputtags possuem nameatributos, caso contrário, elas não estarão presentes 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')])

Somente a txt3entrada tinha um name, então é a única chave presente request.form.