Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

HTTP e API5. La forma della chiamatap. 136

La forma della chiamata, se qualcosa va storto

Dove ha guardato FastAPI, e perché non ha trovato

In questo capitolo quasi tutti gli errori hanno la stessa storia: tu hai scritto una cosa, FastAPI ne ha capita un'altra. Il server parte, la funzione sembra giusta, e la risposta è un 422, un 404 o un 405. Non serve rileggere tutto: chiediti dove ha guardato FastAPI. Te lo dicono due cose, il loc del 422 e la pagina /docs.

Ricorda come si legge un 422: il primo pezzo del loc dice dove (path, query, body), il secondo cosa. E un 422 vuol dire che la tua funzione non è mai partita: FastAPI ha fermato la richiesta prima.

LeggiVuol direCosa fai
"loc":["path","fermate"] e int_parsingNel percorso, dove il def vuole un int, è arrivata una parolaNella richiesta, un numero: /minuti/4, non /minuti/quattro
"loc":["query","treno"] e Field required, ma treno lo volevi nel percorsoIl nome tra graffe e quello nel def sono diversi: un nome che non è tra graffe, per FastAPI, è una queryLo stesso nome, lettera per lettera: {codice} sopra, codice: str sotto
"loc":["query","gruppo"] e Field required, ma il dato era facoltativoManca = None: senza default, una query è obbligatoriagruppo: str | None = None, e dentro if gruppo is None:
"loc":["query","persone"] e Field required, e il dato è obbligatorioLa rotta è giusta: è la richiesta che non l'ha mandatoAggiungi ?persone=3 alla richiesta
"loc":["query","nome"] in una POST che manda un JSONI campi del corpo sono argomenti sciolti nel def: per FastAPI sono query, e il JSON non lo guarda nessunoUn argomento solo, che ha per tipo lo stampo: dati: Gruppo
"loc":["body","persone"] e Field requiredNel JSON manca un campo dello stampoAggiungilo al corpo. In /docs, guarda l'esempio nel Request body
"loc":["body"], Field required e "input":nullIl corpo non è arrivato proprioCon curl: manca -d '…'. In /docs: il riquadro Request body è vuoto
"loc":["body"] e Input should be a valid dictionary or object to extract fields fromIl corpo è arrivato come testo, non come JSONIn curl, con -d sempre anche -H "Content-Type: application/json"
"loc":["query","aperta"] e bool_parsingIn un bool è arrivato si o veroNella query, true o false
{"detail":"Not Found"}, 404Nessuna rotta ha quel percorso. Qui, quasi sempre: un dato della query messo nel decoratore ("/giornaliero/{persone}"), oppure la rotta non l'hai ancora scrittaNel decoratore solo quello che sta prima del ?. Poi confronta il percorso lettera per lettera, barre comprese
{"detail":"Method Not Allowed"}, 405Il percorso c'è, il verbo no. Con curl -i vedi l'header allow, che dice quale verbo accettaIl verbo nel decoratore: @app.put, @app.post, @app.get
ResponseValidationError, Input should be a valid dictionary e 'input': NoneLa funzione non restituisce niente: manca il return, o c'è un print al suo posto. Con -> dict hai promesso un dizionarioreturn e il dizionario della risposta
SyntaxError: parameter without a default follows parameter with a defaultNel def un argomento con = None sta prima di uno senza defaultPrima gli argomenti senza default, poi quelli con = None
TypeError: 'Gruppo' object is not subscriptableLeggi lo stampo come se fosse un dizionario: dati["persone"]Con il punto: dati.persone
Ha risposto 501 {"detail":"Da fare: …"}C'è ancora la riga del 501Al suo posto, il tuo return

Gli errori che non danno errori

I più difficili sono quelli senza 422 e senza traceback: il server risponde 200, ma la risposta è sbagliata. In questo capitolo sono quasi sempre uno di questi quattro. Si trovano solo leggendo la risposta per intero, in /docs o con curl.

Il tipo dimenticato. def giornaliero(persone), senza : int. Nessun errore: persone resta il testo "3", e "3" * 7 fa "3333333". Con un id, la risposta ha "id":"3" invece di "id":3, e /gruppi/tre passa invece di dare 422. Il tipo nel def è l'ordine di convertire: senza, FastAPI ti passa il testo così com'è.

Il None scritto nel testo. = None nel def, ma dentro nessun if … is None:. L'f-string scrive quello che trova: 'Agenzia Bellini - None', «Siamo in ritardo di None minuti».

La f dimenticata. "Buon viaggio, {nome}!" senza la f davanti: esce proprio {nome}, con le graffe.

Il conto all'indietro. a - da senza abs: all'andata va bene, al ritorno le fermate sono negative.

Per trovarli, un breakpoint dentro la rotta e il test lanciato con il debugger: quando si ferma, in VARIABLES vedi cosa è arrivato davvero, e di che tipo ('3' con le virgolette è un testo). Come si fa: Il debugger su FastAPI e nei test.

Quando curl dice Internal Server Error

Un 500 non è un errore di forma: la richiesta è passata, la tua funzione è partita, ed è lei che si è rotta. curl ti dice solo:

Internal Server Error

L'errore vero è nel terminale del server. Per esempio, con dati["persone"] al posto di dati.persone nella rotta 7, nel terminale del server compare:

INFO:     127.0.0.1:63007 - "POST /preventivo HTTP/1.1" 500 Internal Server Error
ERROR:    Exception in ASGI application
Traceback (most recent call last):
…
  File "~/corso/http-forma-della-chiamata/palestra/sportello.py", line 99, in preventivo
    return {"nome": dati["nome"], "persone": dati["persone"], "euro": dati["persone"] * EURO_GIORNALIERO}
                    ~~~~^^^^^^^^
TypeError: 'Gruppo' object is not subscriptable

Le righe in mezzo sono decine, tutte dentro FastAPI: saltale. Si legge dal basso, come in Leggere un traceback: l'ultima riga dice cosa, la riga File … con il tuo file dice dove. Qui: riga 99 di sportello.py, dati è un oggetto, e un oggetto si legge con il punto.

Nei test lo stesso errore arriva direttamente, con la riga del tuo file: il TestClient non lo trasforma in un 500.

Quando il def non è Python valido

Una query facoltativa scritta prima di una obbligatoria:

Python
@app.get("/annuncio")
def annuncio(ritardo: int | None = None, fermata: str) -> dict:

Il server non parte nemmeno. Con python3 sul file si vede l'errore pulito:

Terminale
python3 bordo.py
  File "~/corso/http-forma-della-chiamata/bordo.py", line 15
    def annuncio(ritardo: int | None = None, fermata: str) -> dict:
                                             ^^^^^^^^^^^^
SyntaxError: parameter without a default follows parameter with a default

fastapi dev scrive un riquadro molto più lungo, ma l'ultima riga è la stessa. È una regola di Python, non di FastAPI, la stessa del capitolo Le funzioni: in ogni def, gli argomenti con un default vanno dopo quelli senza. L'ordine nel def non cambia niente per la richiesta, perché FastAPI abbina per nome: scrivi def annuncio(fermata: str, ritardo: int | None = None).

/docs, la lente

Quando un test è rosso e non capisci perché, accendi il server e apri /docs. Lì vedi la rotta come l'ha capita FastAPI, prima ancora di provarla.

In /docs vediVuol dire
L'id del percorso, sotto Parameters, con (query)Il nome tra graffe e quello nel def sono diversi
* required su un dato che doveva essere facoltativoManca = None
Una POST o una PUT senza il riquadro Request bodyI dati non sono in uno stampo
Al posto del Request body, una riga (query) per ogni campoI campi del corpo sono argomenti sciolti
La rotta non c'è proprioIl file non è salvato: il server gira ancora con la versione di prima. Oppure il decoratore manca, o è scritto male

Se il problema non è il codice

command not found: fastapi, Address already in use, /docs che da Windows non si apre, il server che risponde come prima anche se hai cambiato il codice (il file non è salvato): non è la forma della chiamata, è l'ambiente. La tabella è nel README.md dello zip, e le cure, una per una, sono nel Pronto soccorso, alla voce FastAPI.