Vai al contenuto
code-to-code

Apro l'indice…

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

Il database nell'API5. La sessionep. 125

La sessione, le soluzioni

Il ragionamento, il codice, le trappole

Per ogni esercizio, sempre lo stesso ordine: in italiano → il codice → le trappole. Per i 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. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: alcune passano la risposta e si rompono su un test che guarda nel database.

Le soluzioni complete

La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.

db-sessione-soluzioni.zip36 KB

Nei file dello zip le soluzioni hanno gli stampi e i commenti dello scheletro: qui sotto c'è solo il pezzo che hai scritto tu.


La palestra

1 · La stazione per numero

In italiano. Cerco la stazione dal suo id. Se non c'è (None), rispondo 404. Se c'è, la restituisco.

Python
@app.get("/stazioni/{stazione_id}")
def leggi_stazione(stazione_id: int, db: Session = Depends(get_db)) -> Stazione:
    stazione = db.get(StazioneDB, stazione_id)
    if stazione is None:
        raise HTTPException(status_code=404, detail="Stazione non trovata")
    return stazione

db.get è fatta apposta per questo: cerca per chiave primaria, e dà l'oggetto oppure None. Lo stampo Stazione poi lo fa FastAPI: legge gli attributi dell'oggetto e ne fa il JSON.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
stazione = db.get(Stazione, stazione_id)Hai passato lo stampo di Pydantic, non la classe-tabella: NoInspectionAvailable: No inspection system is available for object of type <class 'pydantic._internal._model_construction.ModelMetaclass'>tutti e quattro
niente if stazione is Nonedb.get dà None, la rotta lo restituisce, e FastAPI non riesce a farne una stazione: ResponseValidationError … Input should be a valid dictionary or object to extract fields from. Il client riceve un 500 invece del 404test_stazione_una_che_non_c_e_da_404

2 · Le stazioni aperte

In italiano. Scrivo la domanda in tre pezzi: da StazioneDB, solo dove aperta è vera, in ordine di nome. Poi la eseguo e restituisco la lista.

Python
@app.get("/stazioni")
def stazioni_aperte(db: Session = Depends(get_db)) -> list[Stazione]:
    domanda = select(StazioneDB).where(StazioneDB.aperta).order_by(StazioneDB.nome)
    return db.scalars(domanda).all()

La domanda sta in una variabile (domanda) per leggerla meglio: prima si scrive, poi si esegue. .scalars(…) tiene l'oggetto di ogni riga, .all() fa la lista.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
select(StazioneDB).order_by(StazioneDB.nome), senza whereNessun errore: arrivano tutte e sei le stazioni, anche Vecchia Fiera, che è chiusatest_stazioni_aperte_solo_quelle_aperte, test_stazioni_aperte_in_ordine_di_nome, test_stazioni_aperte_legge_il_database
select(StazioneDB).where(StazioneDB.aperta), senza order_byNessun errore, ma il database non promette nessun ordine: le stazioni escono come sono state scritte (Porta Codice, Via Variabile, Largo Lista…), non in ordine alfabeticotest_stazioni_aperte_in_ordine_di_nome, test_stazioni_aperte_una_riga_intera
return db.execute(domanda).all()Arrivano le righe, non gli oggetti: ogni riga ha dentro un oggetto solo, e FastAPI non trova i campi: ResponseValidationError … Field required per nome, aperta, tornelli, idtutti e quattro

Un errore che non rompe niente. return db.scalars(domanda) senza .all() fa passare tutti i test: la rotta restituisce un ScalarResult e FastAPI lo scorre da solo. Non è sbagliato, ma non è una lista: non puoi contarla né stamparla. Tieni .all().


3 · Chi ha questo badge?

In italiano. Il badge è un testo che non è l'id: db.get non va bene. Scrivo una domanda («la persona con questo badge») e cerco una persona con db.scalar. Se non c'è, 404.

Python
@app.get("/personale/{badge}")
def persona_per_badge(badge: str, db: Session = Depends(get_db)) -> Persona:
    persona = db.scalar(select(PersonaDB).where(PersonaDB.badge == badge))
    if persona is None:
        raise HTTPException(status_code=404, detail="Persona non trovata")
    return persona

Il badge è unico (UNIQUE), quindi la domanda trova al massimo una persona: db.scalar è la mossa giusta. Con B-09 trova Ernesto Pozzi, che nel database è la riga con id 8: il numero del badge e l'id sono due cose diverse.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
persona = db.get(PersonaDB, badge)db.get cerca per chiave primaria, che è un numero: DataError: (psycopg.errors.InvalidTextRepresentation) invalid input syntax for type integer: "B-07"tutti e cinque
select(Persona) (lo stampo al posto della classe-tabella)ArgumentError: Column expression, FROM clause, or other columns clause element expected, got <class 'persona_per_badge.Persona'>.tutti e cinque
niente if persona is Nonedb.scalar dà None, la rotta lo restituisce: ResponseValidationError, 500 invece di 404test_persona_per_badge_uno_che_non_c_e_da_404

Un errore che non rompe niente. db.scalar dà la prima riga, anche se ce n'erano altre. Sul badge, che è unico, non fa differenza. Se cercassi per ruolo (che si ripete), ti darebbe una persona sola senza avvisarti: lì serve db.scalars(…).all().


4 · Un treno nuovo

In italiano.

  1. Con i dati arrivati costruisco un oggetto TrenoDB. Non scrivo l'id: lo sceglie il database.
  2. Lo metto nel carrello (add).
  3. Consegno il carrello (commit): l'INSERT parte e viene confermato.
  4. Riprendo l'oggetto dal database (refresh), così ha l'id e tutti i suoi valori.
  5. Lo restituisco: il decoratore dice che il codice è 201.
Python
@app.post("/treni", status_code=status.HTTP_201_CREATED)
def nuovo_treno(dati: TrenoNuovo, db: Session = Depends(get_db)) -> Treno:
    treno = TrenoDB(
        codice=dati.codice,
        vagoni=dati.vagoni,
        km=dati.km,
        in_servizio=dati.in_servizio,
        stazione_id=dati.stazione_id,
    )
    db.add(treno)
    db.commit()
    db.refresh(treno)
    return treno

Passo per passo.

Rigatreno.idNel database
treno = TrenoDB(…)Noneniente
db.add(treno)Noneniente
db.commit()scelto dal databasela riga c'è
db.refresh(treno)10la riga c'è

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
niente db.commit() (restano add e refresh)Il refresh non trova niente da rileggere: InvalidRequestError: Instance '<TrenoDB at 0x…>' is not persistent within this Session, e il client riceve un 500tutti e quattro
db.flush() al posto di db.commit()Il flush manda il SQL ma non lo conferma: risposta 201 con l'id giusto, e nel database non c'è nientetest_treno_nuovo_e_nel_database, test_treno_nuovo_con_una_stazione
TrenoDB(carrozze=dati.vagoni, …)Una colonna che non esiste: TypeError: 'carrozze' is an invalid keyword argument for TrenoDBtutti e quattro

Il flush è la trappola da ricordare: l'unico test che la prende è quello che guarda dentro il database. Un test che controllasse solo la risposta passerebbe.

Un errore che non rompe niente. Togliere db.refresh(treno): i test restano verdi. Dopo il commit l'oggetto si ricarica da solo quando FastAPI ne legge gli attributi. Non è un errore, ma il refresh dice chiaramente cosa succede: tienilo.


5 · Sposta il treno

In italiano.

  1. Cerco il treno. Se non c'è, 404 «Treno non trovato».
  2. Se la nuova posizione è una stazione (non None), controllo che la stazione esista. Se non c'è, 404 «Stazione non trovata». Con None il treno va al deposito: non c'è niente da controllare.
  3. Cambio l'attributo stazione_id del treno, con il punto.
  4. commit: la sessione si accorge del cambiamento e scrive l'UPDATE.
  5. Restituisco il treno.
Python
@app.put("/treni/{treno_id}/stazione")
def sposta_treno(treno_id: int, dati: Spostamento, db: Session = Depends(get_db)) -> Treno:
    treno = db.get(TrenoDB, treno_id)
    if treno is None:
        raise HTTPException(status_code=404, detail="Treno non trovato")
    if dati.stazione_id is not None and db.get(StazioneDB, dati.stazione_id) is None:
        raise HTTPException(status_code=404, detail="Stazione non trovata")
    treno.stazione_id = dati.stazione_id
    db.commit()
    return treno

Il disegno.

inizio PUT /treni/{treno_id}/stazione passo treno = db.get(TrenoDB, treno_id) se treno is None sì: errore 404 Treno non trovato se stazione_id c'è e la stazione no sì: errore 404 Stazione non trovata passo treno.stazione_id = nuovo valore passo db.commit() restituisci trenoPUT/treni/{treno_id}/stazionetreno = db.get(TrenoDB,treno_id)treno is None404 Treno non trovatostazione_id c'è e lastazione no404 Stazione non trovatatreno.stazione_id = nuovovaloredb.commit()restituisci trenonosìnosì
La rotta che sposta un treno

Passo per passo.

RichiestaCosa succede
PUT /treni/9/stazione con {"stazione_id": 2}trova il T28, trova la stazione 2, cambia l'attributo, commit, 200
PUT /treni/1/stazione con {"stazione_id": null}trova il treno, salta il controllo (è None), cambia l'attributo, commit, 200
PUT /treni/99/stazionedb.get dà None: 404 «Treno non trovato»
PUT /treni/9/stazione con {"stazione_id": 42}trova il treno, ma db.get(StazioneDB, 42) dà None: 404 «Stazione non trovata», e il treno non si muove

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
niente db.commit()La risposta è un 200 con il treno già spostato (l'oggetto in memoria è cambiato), ma il database non ne sa nientetest_sposta_treno_e_nel_database, test_sposta_treno_al_deposito
niente controllo della stazioneIl database rifiuta la stazione che non esiste: IntegrityError: (psycopg.errors.ForeignKeyViolation) insert or update on table "treni" violates foreign key constraint, Key (stazione_id)=(42) is not present in table "stazioni". Il client riceve un 500 invece del 404test_sposta_treno_in_una_stazione_che_non_c_e_da_404
il controllo anche con None (if db.get(StazioneDB, dati.stazione_id) is None)db.get con None non trova nessuna stazione: il deposito diventa un 404 «Stazione non trovata»test_sposta_treno_al_deposito

La prima trappola è la più insidiosa: guardando solo la risposta, tutto sembra giusto. Il test che guarda nel database è rosso così:

E   AssertionError: Lo spostamento non è nel database: c'è il db.commit()?
E   assert [{'stazione_id': 6}] == [{'stazione_id': 2}]

6 · La segnalazione sbagliata

In italiano. Cerco la segnalazione. Se non c'è, 404. Se c'è, la tolgo con db.delete e confermo con commit. Il 204 non ha corpo: niente return.

Python
@app.delete("/segnalazioni/{segnalazione_id}", status_code=status.HTTP_204_NO_CONTENT)
def togli_segnalazione(segnalazione_id: int, db: Session = Depends(get_db)) -> None:
    segnalazione = db.get(SegnalazioneDB, segnalazione_id)
    if segnalazione is None:
        raise HTTPException(status_code=404, detail="Segnalazione non trovata")
    db.delete(segnalazione)
    db.commit()

db.delete vuole l'oggetto, non l'id: per questo prima c'è il db.get.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
niente db.commit()Risposta 204, ma la riga non sparisce: il carrello della cancellazione non è mai partitotest_togli_segnalazione_e_sparita_dal_database, test_togli_segnalazione_le_altre_restano, test_togli_segnalazione_due_volte_la_seconda_da_404
niente if segnalazione is Nonedb.delete(None): UnmappedInstanceError: Class 'builtins.NoneType' is not mapped, e il client riceve un 500 invece del 404test_togli_segnalazione_che_non_c_e_da_404, test_togli_segnalazione_due_volte_la_seconda_da_404

7 · Il badge doppio

In italiano.

  1. Prima di scrivere, chiedo al database: «c'è già una persona con questo badge?». È un db.scalar con un where sul badge.
  2. Se c'è (non è None), rispondo 409 e mi fermo: niente add.
  3. Se non c'è, costruisco la persona, add, commit, refresh.
  4. La restituisco: il decoratore dice 201.
Python
@app.post("/personale", status_code=status.HTTP_201_CREATED)
def nuova_persona(dati: PersonaNuova, db: Session = Depends(get_db)) -> Persona:
    gemella = db.scalar(select(PersonaDB).where(PersonaDB.badge == dati.badge))
    if gemella is not None:
        raise HTTPException(status_code=409, detail="Badge già usato da un'altra persona")
    persona = PersonaDB(
        badge=dati.badge,
        nome=dati.nome,
        ruolo=dati.ruolo,
        stazione_id=dati.stazione_id,
    )
    db.add(persona)
    db.commit()
    db.refresh(persona)
    return persona

Il controllo è sul badge, non sul nome: due persone con lo stesso nome possono esistere (c'è già una Marta Villa, e c'è anche un'altra Villa, Paolo). Il badge no: è UNIQUE nel database.

Il disegno.

inizio POST /personale passo gemella = db.scalar(...badge) se gemella is not None sì: errore 409 Badge già usato passo persona = PersonaDB(...) passo db.add(persona) passo db.commit() passo db.refresh(persona) restituisci personaPOST /personalegemella =db.scalar(...badge)gemella is not None409 Badge già usatopersona = PersonaDB(...)db.add(persona)db.commit()db.refresh(persona)restituisci personanosì
La rotta che crea una persona

Passo per passo.

RichiestaIl controlloIl risultato
badge B-20, nome «Anna Neri»gemella è Noneadd, commit, refresh: 201, id 13
badge B-09trova Ernesto Pozzi409, niente scritto
badge B-20, nome «Marta Villa»gemella è None (il badge non c'è)201: il nome doppio non è un problema

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
niente controlloIl 409 lo dà il database, a modo suo: IntegrityError: (psycopg.errors.UniqueViolation) duplicate key value violates unique constraint "personale_badge_key", Key (badge)=(B-09) already exists. Il client riceve un 500test_persona_nuova_badge_doppio_da_409
controllo sul nome (PersonaDB.nome == dati.nome)Un badge già usato, con un nome diverso, passa il controllo e arriva fino al database (stessa IntegrityError). Una seconda Marta Villa con un badge nuovo, che andrebbe bene, prende un 409test_persona_nuova_badge_doppio_da_409, test_persona_nuova_due_con_lo_stesso_nome_si_puo

Il vincolo UNIQUE del database è l'ultima difesa: anche senza il controllo, il badge doppio non entra mai. Il controllo serve per rispondere come si deve, con un 409 che dice cosa è successo.


La storia

La storia usa un file solo, storia/archivio.py. Prima delle rotte, un pezzo che serve a più livelli: cercare un caso dal numero di fascicolo, o dare il 404.

Python
def trova_caso(fascicolo: str, db: Session) -> CasoDB:
    caso = db.scalar(select(CasoDB).where(CasoDB.fascicolo == fascicolo))
    if caso is None:
        raise HTTPException(status_code=404, detail="Fascicolo non trovato")
    return caso

Livello 1 · Tutti i fascicoli

In italiano. Una domanda sola: tutti i casi, in ordine di fascicolo. La eseguo con scalars e all.

Python
@app.get("/casi")
def lista_casi(db: Session = Depends(get_db)) -> list[Caso]:
    return db.scalars(select(CasoDB).order_by(CasoDB.fascicolo)).all()

Questa è la versione di Nadia con la sessione. Il suo SQL (SELECT * FROM casi ORDER BY fascicolo) è diventato select(CasoDB).order_by(CasoDB.fascicolo): stessa domanda, scritta con le classi.

Livello 2 · Un fascicolo, dal suo numero

In italiano. Il numero di fascicolo (F-25-04) è un testo, non l'id: serve un where, non un get. Cerco con db.scalar; se è None, 404.

Python
@app.get("/casi/{fascicolo}")
def leggi_caso(fascicolo: str, db: Session = Depends(get_db)) -> Caso:
    return trova_caso(fascicolo, db)

Il controllo sta in trova_caso (sopra), che serve anche ai livelli 3 e 4. Nel registro vero, GET /casi/F-25-04 risponde:

$ curl -s http://127.0.0.1:8000/casi/F-25-04
{"id":5,"fascicolo":"F-25-04","titolo":"Le monete di Largo Lista","stazione":"Largo Lista","anno":2025,"aperto":true}

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
db.get(CasoDB, fascicolo) in trova_casodb.get cerca per id, un numero: DataError: (psycopg.errors.InvalidTextRepresentation) invalid input syntax for type integer: "P-02"i dieci test dei livelli 2, 3 e 4 (tutti passano da trova_caso)

Livello 3 · Gli indizi di un caso

In italiano. Trovo il caso (404 se non c'è), poi cerco gli indizi con quel caso_id, dal più vecchio: prima per data, poi per id, così due indizi della stessa notte escono sempre nello stesso ordine.

Python
@app.get("/casi/{fascicolo}/indizi")
def lista_indizi(fascicolo: str, db: Session = Depends(get_db)) -> list[Indizio]:
    caso = trova_caso(fascicolo, db)
    domanda = select(IndizioDB).where(IndizioDB.caso_id == caso.id).order_by(IndizioDB.data, IndizioDB.id)
    return db.scalars(domanda).all()

Con gli indizi veri, per il caso aperto (le stesse righe che dà la rotta, viste da psql):

$ psql -d db_sessione -c "SELECT id, data, badge FROM indizi WHERE caso_id = 5 ORDER BY data, id"
 id |    data    | badge
----+------------+-------
  1 | 2025-10-06 | B-12
  2 | 2025-10-06 | B-11
  3 | 2025-10-06 | B-06
  4 | 2025-10-06 | B-04
  5 | 2025-10-13 | B-06
  6 | 2025-10-13 | B-11
  7 | 2025-10-13 | B-05
  8 | 2025-10-20 | B-12
  9 | 2025-10-20 | B-06
 10 | 2025-10-20 | B-06
 11 | 2025-10-20 | B-11
 12 | 2025-10-20 | B-01
 13 | 2025-10-27 | B-11
 14 | 2025-10-27 | B-05
(14 righe)

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
niente order_byNessun errore: gli indizi escono nell'ordine in cui sono stati scritti, che non è quello delle datetest_livello_3_gli_indizi_dal_piu_vecchio

Livello 4 · Un indizio nuovo

In italiano. Trovo il caso (404 se non c'è). Costruisco un IndizioDB con il caso_id del caso trovato e i dati arrivati. add, commit, refresh: 201.

Python
@app.post("/casi/{fascicolo}/indizi", status_code=status.HTTP_201_CREATED)
def nuovo_indizio(fascicolo: str, dati: IndizioNuovo, db: Session = Depends(get_db)) -> Indizio:
    caso = trova_caso(fascicolo, db)
    indizio = IndizioDB(caso_id=caso.id, data=dati.data, badge=dati.badge, nota=dati.nota)
    db.add(indizio)
    db.commit()
    db.refresh(indizio)
    return indizio

Il caso_id non arriva nel corpo: lo ricavi dal caso, che hai già in mano. Il corpo di Mapelli è l'indizio del 27 ottobre: nella risposta compare con l'id 15.

Livello 5 · Un indizio ricopiato male

In italiano. Cerco l'indizio dall'id (404 se non c'è). Cambio i tre attributi con quelli arrivati, commit, lo restituisco. Il caso_id non si tocca.

Python
@app.put("/indizi/{indizio_id}")
def correggi_indizio(indizio_id: int, dati: IndizioNuovo, db: Session = Depends(get_db)) -> Indizio:
    indizio = db.get(IndizioDB, indizio_id)
    if indizio is None:
        raise HTTPException(status_code=404, detail="Indizio non trovato")
    indizio.data = dati.data
    indizio.badge = dati.badge
    indizio.nota = dati.nota
    db.commit()
    return indizio

Per trovare quale indizio correggere guardi la lista del livello 3: il 13 ottobre c'è un B-11 con id 6, e Mapelli dice che doveva essere B-12.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
niente db.commit()La risposta mostra il badge già corretto (l'oggetto in memoria è cambiato), ma l'archivio non cambia: al prossimo GET il B-11 è ancora lìtest_livello_5_la_correzione_e_nel_database

Livello 6 · Un indizio di troppo

In italiano. Cerco l'indizio dall'id (404 se non c'è), lo tolgo con db.delete, commit. Il 204 non ha corpo.

Python
@app.delete("/indizi/{indizio_id}", status_code=status.HTTP_204_NO_CONTENT)
def togli_indizio(indizio_id: int, db: Session = Depends(get_db)) -> None:
    indizio = db.get(IndizioDB, indizio_id)
    if indizio is None:
        raise HTTPException(status_code=404, detail="Indizio non trovato")
    db.delete(indizio)
    db.commit()

Il doppione è nel registro come due righe uguali, il 20 ottobre, con B-06: gli id 9 e 10. Ne togli uno.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
niente if indizio is Nonedb.delete(None): UnmappedInstanceError: Class 'builtins.NoneType' is not mapped, 500 invece del 404test_livello_6_un_indizio_che_non_c_e

Il finale

Il ragionamento. Per ogni badge, conti in quante notti diverse compare. Lo fai con una psql (ma potevi farlo a occhio, dalla lista del livello 3):

Terminale
psql -d db_sessione -c "SELECT badge, count(DISTINCT data) AS notti, count(*) AS indizi FROM indizi GROUP BY badge ORDER BY notti DESC, badge"

Questo è l'archivio come lo trovi, prima dei ritocchi:

 badge | notti | indizi
-------+-------+--------
 B-11  |     4 |      4
 B-06  |     3 |      4
 B-05  |     2 |      2
 B-12  |     2 |      2
 B-01  |     1 |      1
 B-04  |     1 |      1
(6 righe)

B-11 sembra l'unico presente tutte e quattro le notti (4). Sbagliato: guarda il cartoncino del 13 ottobre. Questa è la pista di Gino D'Alessio, e il commissario risponde:

$ python storia/verifica.py "Gino D'Alessio"
Il commissario Mapelli scuote la testa: «No.»
Rileggi il cartoncino del 13 ottobre: il badge era davvero quello? Guarda il livello 5.

Dopo il livello 4 (l'indizio del 27 ottobre, B-12), B-12 sale a 3 notti:

 badge | notti | indizi
-------+-------+--------
 B-11  |     4 |      4
 B-06  |     3 |      4
 B-12  |     3 |      3
 B-05  |     2 |      2
 B-01  |     1 |      1
 B-04  |     1 |      1
(6 righe)

Dopo il livello 5 (il B-11 del 13 ottobre diventa B-12), B-12 ha 4 notti, B-11 scende a 3. Ma attenzione alla colonna indizi: B-06 ha 4 indizi in 3 notti.

 badge | notti | indizi
-------+-------+--------
 B-12  |     4 |      4
 B-06  |     3 |      4
 B-11  |     3 |      3
 B-05  |     2 |      2
 B-01  |     1 |      1
 B-04  |     1 |      1
(6 righe)

Chi conta le righe invece delle notti si ferma a Pietro Galli, e il commissario risponde:

$ python storia/verifica.py "Pietro Galli"
Il commissario Mapelli scuote la testa: «No.»
Lo stai contando due volte, quel nome: c'è un cartoncino ricopiato in doppio. Guarda il livello 6.

Dopo il livello 6 (il doppione del 20 ottobre se ne va), B-06 ha 3 indizi, e non c'è più niente da confondere:

 badge | notti | indizi
-------+-------+--------
 B-12  |     4 |      4
 B-06  |     3 |      3
 B-11  |     3 |      3
 B-05  |     2 |      2
 B-01  |     1 |      1
 B-04  |     1 |      1
(6 righe)

L'unico badge con 4 notti è B-12. Di chi è?

$ psql -d db_sessione -c "SELECT nome, ruolo FROM personale WHERE badge = 'B-12'"
      nome      |           ruolo
----------------+----------------------------
 Fabio Cattaneo | tecnico delle scale mobili
(1 riga)

La risposta è Fabio Cattaneo, il tecnico delle scale mobili di Ponte Ciclo: il lunedì notte fa la manutenzione anche a Largo Lista, e non ha mai fatto una segnalazione, quindi nessuno gli aveva mai chiesto niente. Mapelli lo scopre solo perché le tre piste sbagliate sono cadute una dopo l'altra:

  • senza il livello 4, B-12 ha 3 notti, come B-06 e B-11: tre nomi a pari merito;
  • senza il livello 5, sembra B-11, Gino D'Alessio;
  • senza il livello 6, un doppione fa contare B-06 due volte.
$ python storia/verifica.py "Fabio Cattaneo"
Il commissario Mapelli annuisce, piano.
«Il lunedì notte fa la manutenzione anche a Largo Lista, e nessuno gli aveva mai chiesto niente.
Domani gli porto un caffè e due domande.»

Pista trovata.