Exercices › Projets guidés › Gerer les erreurs et timeouts
🎉

Bravo!

Intermédiaire 🧠 Fondamentaux 20 XP 0 personnes ont réussi

Gerer les erreurs et timeouts

En production, tout peut echouer. L'API Tavily renvoie une erreur 429 (trop de requetes). Le serveur web que tu scrapes est en panne. L'API OpenAI repond en 30 secondes au lieu de 3. Si ton agent ne gere pas ces cas, il plante au premier probleme.

La strategie standard en production, c'est le retry avec backoff exponentiel. L'idee est simple : si un appel echoue, tu reessaies apres 1 seconde, puis 2 secondes, puis 4 secondes. Tu doubles le delai a chaque tentative. Ca evite de marteler un serveur deja en difficulte.

Pour un agent, il faut aussi un plan B. Si la recherche web echoue apres 3 tentatives, l'agent doit pouvoir repondre sans les resultats web (en utilisant ses connaissances ou en disant "Je n'ai pas pu verifier cette information").

Pour cet exercice, on ne va pas faire de vrais appels ni de vrais delais. On va simuler le mecanisme.

Ecris une fonction executer_avec_retry(fonction, max_tentatives=3, delai_initial=1.0) qui prend une fonction a executer. Elle l'appelle, et si ca leve une exception, elle reessaie jusqu'a max_tentatives fois. Entre chaque tentative, le delai double (backoff exponentiel). La fonction renvoie un dictionnaire avec le resultat ou l'erreur.

Succes : {"succes": True, "resultat": ..., "tentatives": N}
Echec : {"succes": False, "erreur": "...", "tentatives": max_tentatives}

Attention : pour que les tests passent sans attendre, la fonction doit accepter un parametre sleep_fn=None. Si sleep_fn est fourni, elle l'utilise au lieu de time.sleep (injection de dependances encore une fois).

Ecris aussi une fonction executer_avec_fallback(fonction_principale, fonction_fallback) qui essaie d'abord la fonction principale. Si elle echoue, elle appelle la fonction de fallback. Renvoie un dict avec "source" ("principal" ou "fallback") et "resultat".

Exemple :

# Fonction qui echoue 2 fois puis reussit
compteur = [0]
def fragile():
compteur[0] += 1
if compteur[0] < 3:
raise ConnectionError("Serveur indisponible")
return "Resultat"

executer_avec_retry(fragile, max_tentatives=5, sleep_fn=lambda x: None)
renvoie {"succes": True, "resultat": "Resultat", "tentatives": 3}

Tests (4/5)

Fonction qui reussit du premier coup
r = executer_avec_retry(lambda: "ok", max_tentatives=3, sleep_fn=lambda x: None)
assert r == {"succes": True, "resultat": "ok", "tentatives": 1}
Fonction qui echoue puis reussit
compteur = [0]
def fragile():
    compteur[0] += 1
    if compteur[0] < 3:
        raise Exception("echec")
    return "reussi"

r = executer_avec_retry(fragile, max_tentatives=5, sleep_fn=lambda x: None)
assert r["succes"] == True
assert r["resultat"] == "reussi"
assert r["tentatives"] == 3
Fonction qui echoue toujours
def toujours_echec():
    raise ValueError("erreur permanente")

r = executer_avec_retry(toujours_echec, max_tentatives=3, sleep_fn=lambda x: None)
assert r["succes"] == False
assert "erreur" in r
assert r["tentatives"] == 3
Backoff exponentiel correct
delais = []
compteur = [0]
def echec():
    compteur[0] += 1
    raise Exception("fail")

executer_avec_retry(echec, max_tentatives=4, delai_initial=1.0, sleep_fn=lambda d: delais.append(d))
assert len(delais) == 3, f"3 pauses entre 4 tentatives, pas {len(delais)}"
assert delais[0] == 1.0, f"Premier delai doit etre 1.0, pas {delais[0]}"
assert delais[1] == 2.0, f"Deuxieme delai doit etre 2.0, pas {delais[1]}"
assert delais[2] == 4.0, f"Troisieme delai doit etre 4.0, pas {delais[2]}"

+ 0 tests cachés

Indices (3 disponibles)

← Routing intelligent des questions Citer ses sources comme Perplexity →
solution.py