Pydantic, le soluzioni
Il ragionamento, il codice, le trappole
Per ogni esercizio, sempre lo stesso ordine: in italiano → il codice → le trappole. Per i due più difficili, anche il passo per passo.
La tua soluzione è diversa ma i test sono verdi? Probabilmente va bene: spesso ci sono più strade giuste. Leggi comunque le trappole. In questo capitolo quasi tutte passano metà dei test: lo stampo sbagliato accetta i dati giusti, e si tradisce solo con quelli sbagliati.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
1 · L'abbonamento
In italiano. Quattro campi, un tipo per campo. Il titolare è un testo. Le zone si contano, quindi sono un numero intero. Il prezzo ha i centesimi, quindi è un numero con la virgola. Lo studente è sì o no.
class Abbonamento(BaseModel):
titolare: str
zone: int
prezzo: float
studente: boolTutto il resto lo fa Pydantic: "3" diventa 3, "22.5" diventa 22.5, "tante" e 2.5 per le zone sono errori, il titolare senza valore di partenza è obbligatorio, e il colore che non è nello stampo sparisce.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
zone: str | Pydantic non trasforma un numero in testo: zone=2 dà Input should be a valid string. E "3" resta il testo "3": assert '3' == 3. E "tante" passa | test_un_abbonamento_giusto, test_i_numeri_scritti_come_testo_diventano_numeri, test_zone_scritte_a_parole_sono_un_errore, test_un_campo_in_piu_si_ignora |
prezzo: int | 39.5 ha la virgola: Input should be a valid integer, got a number with a fractional part (int_from_float). E "22.5" non si legge come intero (int_parsing) | test_un_abbonamento_giusto, test_i_numeri_scritti_come_testo_diventano_numeri, test_un_campo_in_piu_si_ignora |
zone: float | Le zone 2.5 passano: Failed: DID NOT RAISE ValidationError | test_le_zone_sono_un_numero_intero |
La terza è la più subdola: tutti gli altri test sono verdi. "3" diventa 3.0, e per Python 3.0 == 3 è vero. Solo le mezze zone la tradiscono. Scegli il tipo pensando a cosa non deve passare: si possono comprare 2 zone e mezzo? No: int.
2 · Gli oggetti smarriti
In italiano. L'oggetto e la stazione ci sono sempre: due testi obbligatori. Il colore è un testo oppure None, e se non arriva vale None.
class OggettoSmarrito(BaseModel):
oggetto: str
stazione: str
colore: str | None = NoneLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
colore: str | None | Senza = il campo è obbligatorio, anche se accetta None: un oggetto senza colore dà Field required | test_senza_colore_il_colore_e_none, test_nel_dizionario_c_e_anche_il_colore_vuoto |
colore: str = None | Se il colore non arriva, vale None e va bene. Ma se arriva None (in JSON, null), Pydantic lo controlla con il tipo: Input should be a valid string | test_il_colore_puo_arrivare_vuoto |
stazione: str | None = None | Tutto facoltativo: un ombrello senza stazione passa, e nessuno saprà mai dove cercarlo. Failed: DID NOT RAISE ValidationError | test_la_stazione_e_obbligatoria |
Le prime due sono la tabella dell'esempio B, in un caso vero. Il tipo dice cosa può arrivare, il = dice cosa vale quando non arriva niente: servono tutti e due.
3 · La ricarica
In italiano.
- La tessera è un testo lungo esattamente 6: almeno 6 e al massimo 6.
- L'importo è un numero con la virgola, più di 0 (lo zero escluso) e al massimo 100 (il 100 compreso).
class Ricarica(BaseModel):
tessera: str = Field(min_length=6, max_length=6)
importo: float = Field(gt=0, le=100)Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
importo: float = Field(ge=0, le=100) | Con ge lo zero è ammesso: la ricarica di 0 euro passa | test_zero_euro_non_sono_una_ricarica |
importo: float = Field(gt=0, lt=100) | Con lt il 100 è escluso: Input should be less than 100 (less_than) | test_cento_euro_si_possono_caricare |
tessera: str = Field(min_length=6) | Solo il minimo: un codice di 7 caratteri passa | test_codice_troppo_lungo |
Per le prime due, la domanda è sempre la stessa: il confine è ammesso? Leggi la storia parola per parola. «Più di 0»: lo zero no, gt. «Al massimo 100»: il 100 sì, le. La e finale di ge e le vuol dire equal, «uguale»: il confine è dentro.
4 · I turni
In italiano. Il badge è un testo. La fascia è un testo, ma solo uno dei tre: Literal, con i tre valori. Le ore sono un numero intero da 1 a 8, estremi compresi.
class Turno(BaseModel):
badge: str
fascia: Literal["mattina", "pomeriggio", "notte"]
ore: int = Field(ge=1, le=8)Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
fascia: str | Qualsiasi testo passa: «pranzo», «Notte», anche «boh» | test_una_fascia_che_non_esiste, test_le_maiuscole_contano |
fascia: Literal["mattina, pomeriggio, notte"] | Un testo solo, con le virgole dentro. L'unico valore ammesso è proprio "mattina, pomeriggio, notte": "notte" dà Input should be 'mattina, pomeriggio, notte' | test_un_turno_giusto, test_le_tre_fasce |
La seconda si vede bene nel messaggio: Pydantic elenca i valori ammessi, e ce n'è uno solo. Contali: ogni valore ha le sue virgolette.
5 · Il treno nuovo
In italiano.
- Prendo i dati del treno, un
TrenoNuovo, e li trasformo in un dizionario conmodel_dump(). - Apro il dizionario con le due stelle: ogni campo diventa un argomento con il nome.
- Davanti metto l'id scelto dal deposito, con il suo nome.
- Restituisco il
Trenoche ne esce.
def registra_treno(dati: TrenoNuovo, nuovo_id: int) -> Treno:
return Treno(id=nuovo_id, **dati.model_dump())La versione lunga è giusta anche lei, purché ci siano tutti e quattro i campi:
def registra_treno(dati: TrenoNuovo, nuovo_id: int) -> Treno:
return Treno(id=nuovo_id, codice=dati.codice, tipo=dati.tipo, vagoni=dati.vagoni, guasto=dati.guasto)Passo per passo, con registra_treno(TrenoNuovo(codice="M18", tipo="metro", vagoni=4), 7):
| Il pezzo | Che cos'è |
|---|---|
dati | TrenoNuovo(codice='M18', tipo='metro', vagoni=4, guasto=None) |
dati.model_dump() | {"codice": "M18", "tipo": "metro", "vagoni": 4, "guasto": None} |
**dati.model_dump() | codice="M18", tipo="metro", vagoni=4, guasto=None |
Treno(id=nuovo_id, **dati.model_dump()) | Treno(id=7, codice="M18", tipo="metro", vagoni=4, guasto=None) |
Il disegno.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return dati | Restituisce il TrenoNuovo così com'è, senza id: AttributeError: 'TrenoNuovo' object has no attribute 'id' | test_restituisce_un_treno, test_il_treno_ha_l_id_del_deposito, test_il_treno_in_json |
La versione lunga senza guasto=dati.guasto | Nessun errore: il guasto è facoltativo, e Pydantic mette None. «freni consumati» sparisce: assert None == 'freni consumati' | test_anche_il_guasto_passa |
Treno(id=nuovo_id, **dati) | Le stelle vogliono un dizionario, non un oggetto: TypeError: registra_treno.Treno() argument after ** must be a mapping, not TrenoNuovo | tutti e cinque |
Treno(nuovo_id, **dati.model_dump()) | L'id senza nome: TypeError: BaseModel.__init__() takes 1 positional argument but 2 were given | tutti e cinque |
La seconda è la più pericolosa, perché non si ferma niente: un campo facoltativo dimenticato diventa None in silenzio. Le due stelle non dimenticano: il dizionario di model_dump() ha sempre tutti i campi.
6 · I rimborsi
In italiano. Uno stampo con cinque campi, uno per riga della docstring:
- La tessera: un testo.
- Il ritardo: un intero, almeno 15.
- Il prezzo: un numero con la virgola, più di 0.
- Il canale: solo «app» o «biglietteria».
- La nota: un testo oppure
None, e se manca valeNone.
class RichiestaRimborso(BaseModel):
tessera: str
ritardo: int = Field(ge=15)
prezzo: float = Field(gt=0)
canale: Literal["app", "biglietteria"]
nota: str | None = NoneLa rotta non cambia: legge richiesta.ritardo, richiesta.prezzo e richiesta.tessera con il punto. Con lo scheletro vuoto quei campi non c'erano, e ogni test si fermava con AttributeError: 'RichiestaRimborso' object has no attribute 'ritardo'.
Passo per passo: cosa controlla ogni test, e quale riga dello stampo lo fa diventare verde.
| Il test | Manda | Risponde | Grazie a |
|---|---|---|---|
test_un_rimborso_giusto | tutto giusto, senza nota | 200, {"tessera": "MN1042", "euro": 1.1} | nota: str | None = None |
test_un_ora_di_ritardo_rimborsa_tutto | "ritardo": "75", con la nota | 200, {"tessera": "TS0007", "euro": 2.2} | ritardo: int: il testo "75" diventa 75, e 75 è almeno 60 |
test_ritardo_troppo_corto | "ritardo": 10 | 422, ["body", "ritardo"], greater_than_equal | Field(ge=15) |
test_ritardo_scritto_a_parole | "ritardo": "tanto" | 422, ["body", "ritardo"], int_parsing | ritardo: int |
test_prezzo_zero | "prezzo": 0 | 422, ["body", "prezzo"], greater_than | Field(gt=0) |
test_canale_sconosciuto | "canale": "telefono" | 422, ["body", "canale"], literal_error | Literal["app", "biglietteria"] |
test_manca_la_tessera | niente tessera | 422, ["body", "tessera"], missing | tessera: str, senza = |
Nei test con il 422, la funzione calcola_rimborso non parte mai: FastAPI risponde prima, con l'elenco degli errori.
Le trappole. Qui lo stampo sta in un file con una rotta, quindi ogni trappola è il file intero con una riga cambiata.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
ritardo: int | Il tipo c'è, la regola no: 10 minuti di ritardo passano, e la rotta rimborsa 1.1 euro. assert 200 == 422 | test_ritardo_troppo_corto |
canale: str | Qualsiasi canale passa, anche «telefono»: assert 200 == 422 | test_canale_sconosciuto |
nota: str | None | La nota diventa obbligatoria: la richiesta giusta, che non ha la nota, riceve 422 con missing su ["body", "nota"]. assert 422 == 200 | test_un_rimborso_giusto |
La terza è la trappola dell'esercizio 2, arrivata fino al client: per lui è un 422 su una richiesta giusta. Se un test con dati giusti dice assert 422 == 200, manda la stessa richiesta da /docs e leggi il detail: loc ti dice il campo che lo stampo vuole e non trova.