Retry et timeouts pour rendre le script plus robuste

1. Gestion des erreurs dans les scripts

Problèmes du web scraping

Imagine : ton script est en mode super cool, prêt à bosser, mais, oh là là, il glisse sur une peau de banane — et bam ! Erreurs et bugs. Alors, comment s’assurer qu’il survivra dans les conditions impitoyables d’Internet ? Aujourd’hui, on va lui apprendre deux compétences cruciales : la persévérance et la répétition des tentatives. Oui, tu as bien entendu, on configure les retry et les timeouts.

Travailler avec le web scraping peut être sympa jusqu’à ce que tu réalises que ton script se coupe soudainement à cause de :

• Problèmes de connexion.
• Indisponibilité temporaire des serveurs.
• Changements imprévisibles dans la structure HTML des pages.

Ton script, tel un Jedi, doit être prêt pour les surprises et savoir comment les gérer. Parfois, les problèmes peuvent être résolus en attendant une minute et en renvoyant la requête. Et c’est là que nos héros entrent en scène — les retry et les timeouts !

Introduction aux mécanismes de gestion des erreurs

Pour commencer, rappelons les bases : la gestion des erreurs en Python. On utilise les blocs try-except pour gérer les erreurs et éviter qu’elles ne sabotent le fonctionnement de notre script.

import requests

try:
    response = requests.get('https://example.com')
    response.raise_for_status()  # vérification de la réussite de la requête
except requests.exceptions.RequestException as e:
    print(f'Une erreur s\'est produite : {e}')

2. Configuration des retry

Pourquoi utiliser des tentatives répétées ?

Un script qui abandonne à la première erreur, c’est comme un chat qui a peur d’une petite pluie. Mais toi, tu as besoin d’un script qui peut faire face à deux ou trois pépins. C’est pour cela qu’on configure des retry — ton script deviendra un vrai pro.

Comment configurer les tentatives répétées

Maintenant, voyons comment on peut organiser des tentatives répétées. Une méthode simple est d’utiliser la bibliothèque urllib3, qui fournit une fonctionnalité pour automatiquement renvoyer la requête en cas d’erreurs.

from urllib3.util.retry import Retry
from requests.adapters import HTTPAdapter
import requests

session = requests.Session()
retries = Retry(total=5, backoff_factor=1, status_forcelist=[500, 502, 503, 504])
session.mount('https://', HTTPAdapter(max_retries=retries))

try:
    response = session.get('https://example.com')
    response.raise_for_status()
    print(response.content)
except requests.exceptions.RequestException as e:
    print(f'Une erreur s\'est produite : {e}')

Dans cet exemple, on a créé une session à laquelle on a appliqué le mécanisme des retry (Retry). On a dit qu’il fallait faire jusqu’à 5 tentatives en cas d’échecs avec les codes 500, 502, 503 et 504. backoff_factor=1 signifie que le délai entre les tentatives augmentera selon un principe de croissance exponentielle (1, 2, 4, 8... secondes).

3. Timeouts : éviter les blocages

On arrête d’attendre indéfiniment

Les timeouts sont comme un réveil : ils empêchent de rester bloqué en attendant une réponse du serveur. En paramétrant un timeout, tu dis à ton script : "Arrête d’attendre ! Si le serveur ne répond pas dans le temps imparti, passe à autre chose !"

try:
    response = requests.get('https://example.com', timeout=10)
    response.raise_for_status()
    print(response.content)
except requests.exceptions.Timeout:
    print('La requête a dépassé le temps d\'attente')
except requests.exceptions.RequestException as e:
    print(f'Une erreur s\'est produite : {e}')

Pourquoi en a-t-on besoin ?

As-tu déjà attendu, figé, que ton script reçoive une réponse d’un serveur qui est déjà grillé comme un toast ? Les timeouts évitent les attentes inutiles et permettent à ton code de se remettre rapidement et de continuer à travailler. Ne fais pas "croire" à ton script qu’il pourrait aller fumer une clope pendant ce temps !

4. Exemples de configuration

Implémentation d’un script robuste avec retry

Maintenant, construisons notre script qui sera robuste comme l’armure d’Iron Man. On va utiliser à la fois les timeouts et les retry.

from urllib3.util.retry import Retry
from requests.adapters import HTTPAdapter
import requests

def fetch_url(url):
    session = requests.Session()
    retries = Retry(total=5, backoff_factor=1, status_forcelist=[500, 502, 503, 504])
    session.mount('https://', HTTPAdapter(max_retries=retries))

    try:
        response = session.get(url, timeout=10)
        response.raise_for_status()
        return response.content
    except requests.exceptions.Timeout:
        print('La requête a dépassé le temps d\'attente')
    except requests.exceptions.RequestException as e:
        print(f'Une erreur s\'est produite : {e}')
    return None

content = fetch_url('https://example.com')
if content:
    print('Données téléchargées avec succès !')

Utilisation des timeouts pour éviter que le script ne se bloque

On a déjà montré comment configurer des timeouts. Maintenant, assurons-nous que notre script ne soit pas seulement robuste, mais qu’il réagisse de manière intelligente face à une longue attente. Au lieu de "planter", il notifiera juste son maître : "Eh, le serveur réfléchit trop longtemps, je ne vais pas attendre indéfiniment !"

Ce genre d’approche simple et efficace rendra ton code fiable et prêt à affronter toutes les situations imprévisibles qu’Internet pourrait réserver.

Application pratique

Quand tu développes des projets de scraping réels, tu dois souvent faire face à des limitations imposées par les serveurs. Les retry et les timeouts sont tes meilleurs alliés pour minimiser les risques de bugs. Cela t’aidera à garantir le bon fonctionnement de ton code, surtout en cas de traitement automatisé des données, où il est crucial d’obtenir des résultats précis dans les délais. Ces techniques peuvent aussi améliorer ton CV et renforcer la confiance des clients à qui tu fournis des données.