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.
| Leggi | Vuol dire | Cosa fai |
|---|---|---|
"loc":["path","fermate"] e int_parsing | Nel percorso, dove il def vuole un int, è arrivata una parola | Nella richiesta, un numero: /minuti/4, non /minuti/quattro |
"loc":["query","treno"] e Field required, ma treno lo volevi nel percorso | Il nome tra graffe e quello nel def sono diversi: un nome che non è tra graffe, per FastAPI, è una query | Lo stesso nome, lettera per lettera: {codice} sopra, codice: str sotto |
"loc":["query","gruppo"] e Field required, ma il dato era facoltativo | Manca = None: senza default, una query è obbligatoria | gruppo: str | None = None, e dentro if gruppo is None: |
"loc":["query","persone"] e Field required, e il dato è obbligatorio | La rotta è giusta: è la richiesta che non l'ha mandato | Aggiungi ?persone=3 alla richiesta |
"loc":["query","nome"] in una POST che manda un JSON | I campi del corpo sono argomenti sciolti nel def: per FastAPI sono query, e il JSON non lo guarda nessuno | Un argomento solo, che ha per tipo lo stampo: dati: Gruppo |
"loc":["body","persone"] e Field required | Nel JSON manca un campo dello stampo | Aggiungilo al corpo. In /docs, guarda l'esempio nel Request body |
"loc":["body"], Field required e "input":null | Il corpo non è arrivato proprio | Con curl: manca -d '…'. In /docs: il riquadro Request body è vuoto |
"loc":["body"] e Input should be a valid dictionary or object to extract fields from | Il corpo è arrivato come testo, non come JSON | In curl, con -d sempre anche -H "Content-Type: application/json" |
"loc":["query","aperta"] e bool_parsing | In un bool è arrivato si o vero | Nella query, true o false |
{"detail":"Not Found"}, 404 | Nessuna rotta ha quel percorso. Qui, quasi sempre: un dato della query messo nel decoratore ("/giornaliero/{persone}"), oppure la rotta non l'hai ancora scritta | Nel decoratore solo quello che sta prima del ?. Poi confronta il percorso lettera per lettera, barre comprese |
{"detail":"Method Not Allowed"}, 405 | Il percorso c'è, il verbo no. Con curl -i vedi l'header allow, che dice quale verbo accetta | Il verbo nel decoratore: @app.put, @app.post, @app.get |
ResponseValidationError, Input should be a valid dictionary e 'input': None | La funzione non restituisce niente: manca il return, o c'è un print al suo posto. Con -> dict hai promesso un dizionario | return e il dizionario della risposta |
SyntaxError: parameter without a default follows parameter with a default | Nel def un argomento con = None sta prima di uno senza default | Prima gli argomenti senza default, poi quelli con = None |
TypeError: 'Gruppo' object is not subscriptable | Leggi 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 501 | Al 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 ErrorL'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 subscriptableLe 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:
@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:
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 defaultfastapi 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 vedi | Vuol 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 facoltativo | Manca = None |
| Una POST o una PUT senza il riquadro Request body | I dati non sono in uno stampo |
Al posto del Request body, una riga (query) per ogni campo | I campi del corpo sono argomenti sciolti |
| La rotta non c'è proprio | Il 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.