Retries e timeouts para deixar seu script mais robusto

1. Tratamento de erros em scripts

Problemas em web scraping

Imagina: seu script está todo arrumadinho, pronto pra rodar, mas de repente escorrega na casca de uma banana — e pimba! Erros e falhas. Como fazer com que ele sobreviva nas condições brutais da Internet? Hoje a gente vai ensinar seu script duas habilidades essenciais: resistência e repetir tentativas. Isso mesmo, vamos configurar retries e timeouts.

Trabalhar com web scraping pode ser incrível até o momento em que você percebe que o script caiu fora por causa de:

• Problemas de conexão.
• Servidores temporariamente indisponíveis.
• Mudanças imprevisíveis na estrutura HTML das páginas.

Seu script, como um Jedi, precisa estar preparado para o inesperado e saber lidar com isso. Às vezes, os problemas podem ser resolvidos só esperando um pouquinho e tentando de novo. E é aí que entram os nossos heróis — retries e timeouts!

Introdução aos mecanismos de tratamento de erros

Primeiro, vamos relembrar o básico — tratamento de erros em Python. Usamos blocos try-except pra lidar com erros e evitar que eles destruam a execução do nosso script.

import requests

try:
    response = requests.get('https://example.com')
    response.raise_for_status()  # verificar se a requisição foi bem-sucedida
except requests.exceptions.RequestException as e:
    print(f'Ocorreu um erro: {e}')

2. Configurando retries

Por que usar tentativas repetidas?

Um script que desiste no primeiro erro é como um gatinho com medo de uma tempestade. Mas você quer um script que aguente firme alguns incômodos. É exatamente por isso que configuramos retries — pra deixar seu script mais confiante.

Como configurar tentativas repetidas

Vamos entender como podemos configurar as tentativas repetidas. Uma das formas mais simples é usar a biblioteca urllib3, que oferece funcionalidade para reenviar automaticamente a requisição em caso de erros.

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'Ocorreu um erro: {e}')

Neste exemplo, criamos uma session e aplicamos a ela o mecanismo de tentativas repetidas (Retry). Informamos que devem ser feitas até 5 tentativas em caso de erro com os códigos 500, 502, 503 e 504. backoff_factor=1 significa que o tempo entre as tentativas vai aumentar de forma exponencial (1, 2, 4, 8... segundos).

3. Timeouts: evitando travamentos

Adie a espera caprichosa

Timeouts são como despertadores: ajudam a evitar travamentos enquanto espera a resposta de um servidor. Estabelecendo um timeout, você diz ao seu script: "Já deu! Se o servidor não responder dentro do tempo especificado, segue o baile!"

try:
    response = requests.get('https://example.com', timeout=10)
    response.raise_for_status()
    print(response.content)
except requests.exceptions.Timeout:
    print('A requisição ultrapassou o tempo limite')
except requests.exceptions.RequestException as e:
    print(f'Ocorreu um erro: {e}')

Por que é útil?

Você já ficou esperando seu script receber a resposta de um servidor que já fritou como uma torrada? Timeouts evitam esperas desnecessárias e dão ao seu código a chance de se recuperar rápido e continuar rodando. Não faça seu script "pensar" que deu tempo de ir fumar um cigarro algumas vezes enquanto espera!

4. Exemplos de configuração

Implementando um script robusto com retries

Agora vamos montar um script que será tão resistente quanto a armadura do Homem de Ferro. Vamos usar tanto timeouts quanto retries.

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('A requisição ultrapassou o tempo limite')
    except requests.exceptions.RequestException as e:
        print(f'Ocorreu um erro: {e}')
    return None

content = fetch_url('https://example.com')
if content:
    print('Dados baixados com sucesso!')

Usando timeouts pra evitar que o script trave

Já mostramos como configurar timeouts. Agora vamos garantir que nosso script não só seja robusto, mas também reaja de maneira inteligente a longas esperas. Em vez de "travar", ele apenas avisa ao dono: "Ei, o servidor está demorando muito, não vou esperar!"

Esse é um jeito simples e prático de deixar seu código confiável e pronto pra batalhar com várias situações imprevisíveis que a Internet pode jogar no seu caminho.

Aplicação prática

Quando você desenvolve projetos reais de scraping, frequentemente precisa lidar com várias limitações impostas pelos servidores. Retries e timeouts são seus melhores amigos para minimizar riscos de falha. Isso vai te ajudar a garantir que seu código rode direto, especialmente quando você precisa de resultados precisos e dentro do prazo. Essas técnicas também podem dar um upgrade no seu currículo e aumentar a confiança dos clientes pra quem você fornece dados.