Enviando respostas em FastAPI
Um dos aspectos fundamentais do FastAPI é sua capacidade de processar solicitações HTTP utilizando funções simples. Considere o exemplo básico abaixo:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def root():
return {"message": "Hello www.programicio.com!"}Neste exemplo, a função root processa as solicitações HTTP do tipo GET na raiz da aplicação e retorna um dicionário contendo o elemento "message". Durante o envio dessa resposta, os dados são automaticamente serializados no formato JSON, amplamente utilizado para comunicação entre cliente e servidor. Além disso, o cabeçalho de tipo de conteúdo (Content-Type) da resposta é configurado como application/json.
Serialização de Dados em FastAPI
Por padrão, uma função pode retornar qualquer tipo de dado em FastAPI como, por exemplo, dicionários, listas, strings, números, etc.
Esses dados são automaticamente serializados em JSON utilizando o codificador fastapi.encoders.jsonable_encoder. O envio da resposta é gerenciado pela classe fastapi.responses.JSONResponse.
O código inicial, na verdade, é equivalente a este:
from fastapi import FastAPI
from fastapi.responses import JSONResponse
from fastapi.encoders import jsonable_encoder
app = FastAPI()
@app.get("/")
def root():
data = {"message": "Hello www.programicio.com!"}
json_data = jsonable_encoder(data)
return JSONResponse(content=json_data)Aqui, o parâmetro content define os dados a serem enviados. Alternativamente, é possível omitir a serialização explícita e passar os dados diretamente ao JSONResponse:
from fastapi import FastAPI
from fastapi.responses import JSONResponse
app = FastAPI()
@app.get("/")
def root():
return JSONResponse(content={"message": "Hello www.programicio.com!"})Caso seja necessário enviar dados que não podem ser serializados diretamente ou personalizar a serialização padrão, é possível definir um serializador JSON próprio.
Respostas Não JSON
Uma função em FastAPI não precisa obrigatoriamente retornar dados em formato JSON. É possível enviar respostas em outros formatos, utilizando objetos da classe Response ou de suas subclasses, como JSONResponse.
A classe fastapi.Response serve como base para outras classes de resposta e permite enviar respostas em formatos personalizados. Seu construtor aceita os seguintes parâmetros:
content: o conteúdo da resposta.status_code: o código de status HTTP.media_type: o tipo MIME da resposta.headers: cabeçalhos personalizados.
Veja um exemplo básico:
from fastapi import FastAPI, Response
app = FastAPI()
@app.get("/")
def root():
data = "Hello www.programicio.com!"
return Response(content=data, media_type="text/plain")Nesse caso, a resposta é um texto simples ("Hello www.programicio.com!") com o tipo MIME definido como text/plain.
PlainTextResponse
Para enviar texto simples, é possível utilizar a subclasse PlainTextResponse que define o tipo MIME como text/plain automaticamente:
from fastapi import FastAPI
from fastapi.responses import PlainTextResponse
app = FastAPI()
@app.get("/")
def root():
data = "Hello www.programicio.com!"
return PlainTextResponse(content=data)HTMLResponse
Para facilitar o envio de código HTML, a classe HTMLResponse ajusta automaticamente o cabeçalho Content-Type para text/html:
from fastapi import FastAPI
from fastapi.responses import HTMLResponse
app = FastAPI()
@app.get("/")
def root():
data = "<h2>Hello www.programicio.com!</h2>"
return HTMLResponse(content=data)
Definindo o Tipo de Resposta com response_class
Os métodos de FastAPI, como @app.get() e @app.post(), permitem especificar o tipo de resposta diretamente utilizando o parâmetro response_class. Veja o exemplo:
from fastapi import FastAPI
from fastapi.responses import PlainTextResponse, JSONResponse, HTMLResponse
app = FastAPI()
@app.get("/hello", response_class=PlainTextResponse)
def root_text():
return "Hello www.programicio.com!"
@app.get("/goodbye", response_class=HTMLResponse)
def root_html():
return "<h2>Goodbye www.programicio.com!</h2>"Documentação oficial: