Bisakah saya menetapkan max_retries untuk requests.request?

Modul permintaan Python sederhana dan elegan tetapi satu hal mengganggu saya. Dimungkinkan untuk mendapatkan requests.exception.ConnectionError dengan pesan seperti:

Max retries exceeded with url: ...

Ini menyiratkan bahwa permintaan dapat mencoba mengakses data beberapa kali. Tetapi tidak ada satu pun penyebutan kemungkinan ini di dokumen. Melihat kode sumber saya tidak menemukan tempat di mana saya dapat mengubah nilai default (mungkin 0).

Jadi, mungkinkah untuk menetapkan jumlah percobaan ulang maksimum untuk permintaan?

Ini adalah urllib3pustaka dasar yang melakukan pengulangan. Untuk menetapkan jumlah coba ulang maksimum yang berbeda, gunakan adapter transportasi alternatif :

from requests.adapters import HTTPAdapter

s = requests.Session()
s.mount('http://stackoverflow.com', HTTPAdapter(max_retries=5))

The max_retriesArgumen mengambil integer atau Retry()objek ; yang terakhir memberi Anda kendali halus atas jenis kegagalan apa yang dicoba (nilai integer diubah menjadi Retry()instance yang hanya menangani kegagalan koneksi; kesalahan setelah koneksi dibuat secara default tidak ditangani karena ini dapat menyebabkan efek samping) .

Jawaban lama, sebelum rilis permintaan 1.2.1 :

The requestsperpustakaan tidak benar-benar membuat dikonfigurasi ini, juga tidak berniat untuk (melihat permintaan tarik ini ). Saat ini (permintaan 1.1), jumlah percobaan ulang diatur ke 0. Jika Anda benar-benar ingin mengaturnya ke nilai yang lebih tinggi, Anda harus mengatur ini secara global:

import requests

requests.adapters.DEFAULT_RETRIES = 5

Konstanta ini tidak didokumentasikan; gunakan dengan risiko Anda sendiri karena rilis mendatang dapat mengubah cara penanganannya.

Perbarui : dan ini memang berubah; dalam versi 1.2.1 opsi untuk mengatur max_retriesparameter pada HTTPAdapter()kelas telah ditambahkan, sehingga sekarang Anda harus menggunakan adapter transportasi alternatif, lihat di atas. Pendekatan monkey-patch tidak lagi berfungsi, kecuali jika Anda juga menambal HTTPAdapter.__init__()default (sangat tidak disarankan).

Ini tidak hanya akan mengubah max_retries tetapi juga mengaktifkan strategi backoff yang membuat permintaan ke semua http: // alamat tidur untuk jangka waktu tertentu sebelum mencoba lagi (hingga total 5 kali):

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

s = requests.Session()

retries = Retry(total=5,
                backoff_factor=0.1,
                status_forcelist=[ 500, 502, 503, 504 ])

s.mount('http://', HTTPAdapter(max_retries=retries))

s.get('http://httpstat.us/500')

Sesuai dokumentasi untukRetry : jika backoff_factor adalah 0,1 , maka sleep () akan tidur selama [ 0,1 detik, 0,2 detik, 0,4 detik, ...] di antara percobaan ulang. Ini juga akan memaksa mencoba ulang jika kode status yang dikembalikan adalah 500 , 502 , 503 atau 504 .

Berbagai opsi lain untuk Retrymemungkinkan kontrol yang lebih terperinci:

• total - Total jumlah percobaan yang diizinkan.
• connect - Berapa banyak kesalahan yang berhubungan dengan koneksi untuk mencoba kembali.
• baca - Berapa kali untuk mencoba lagi kesalahan baca.
• redirect - Berapa banyak pengalihan yang harus dilakukan.
• method_whitelist - Kumpulan kata kerja metode HTTP huruf besar yang harus kita coba lagi.
• status_forcelist - Satu set kode status HTTP yang harus kita coba lagi coba.
• backoff_factor - Faktor backoff untuk diterapkan di antara upaya.
• rais_on_redirect - Apakah, jika jumlah pengalihan habis, untuk meningkatkan MaxRetryError, atau untuk mengembalikan respons dengan kode respons dalam kisaran 3xx .
• rais_on_status - Arti yang mirip dengan rais_on_redirect : apakah kita harus meningkatkan pengecualian, atau mengembalikan respons, jika statusnya jatuh dalam rentang status_forcelist dan coba lagi telah habis.

NB : meningkatkan_on_status relatif baru, dan belum membuatnya menjadi rilis urllib3 atau permintaan. The raise_on_status argumen kata kunci tampaknya telah berhasil masuk ke perpustakaan standar paling di python versi 3.6.

Untuk membuat permintaan coba lagi pada kode status HTTP tertentu, gunakan status_forcelist . Misalnya, status_forcelist = [503] akan mencoba lagi pada kode status 503 (layanan tidak tersedia).

Secara default, coba lagi hanya untuk kondisi berikut:

• Tidak bisa mendapatkan koneksi dari kolam.
• TimeoutError
• HTTPExceptiondimunculkan (dari http.client dengan Python 3 lain httplib ). Ini tampaknya merupakan pengecualian HTTP tingkat rendah, seperti URL atau protokol yang tidak dibentuk dengan benar.
• SocketError
• ProtocolError

Perhatikan bahwa ini adalah semua pengecualian yang mencegah respons HTTP reguler diterima. Jika ada respons reguler yang dihasilkan, coba ulang tidak dilakukan. Tanpa menggunakan status_forcelist , bahkan respons dengan status 500 tidak akan dicoba lagi.

Untuk membuatnya berperilaku dengan cara yang lebih intuitif untuk bekerja dengan API atau server web jarak jauh, saya akan menggunakan cuplikan kode di atas, yang memaksa mencoba lagi pada status 500 , 502 , 503 dan 504 , yang semuanya tidak biasa pada web dan (mungkin) dapat dipulihkan mengingat periode backoff yang cukup besar.

Diedit : Retrykelas impor langsung dari urllib3 .

Hati-hati, jawaban Martijn Pieters tidak cocok untuk versi 1.2.1+. Anda tidak dapat mengaturnya secara global tanpa menambal perpustakaan.

Anda bisa melakukan ini sebagai gantinya:

import requests
from requests.adapters import HTTPAdapter

s = requests.Session()
s.mount('http://www.github.com', HTTPAdapter(max_retries=5))
s.mount('https://www.github.com', HTTPAdapter(max_retries=5))

Setelah berjuang sedikit dengan beberapa jawaban di sini, saya menemukan sebuah perpustakaan bernama backoff yang berfungsi lebih baik untuk situasi saya. Contoh dasar:

import backoff

@backoff.on_exception(
    backoff.expo,
    requests.exceptions.RequestException,
    max_tries=5,
    giveup=lambda e: e.response is not None and e.response.status_code < 500
)
def publish(self, data):
    r = requests.post(url, timeout=10, json=data)
    r.raise_for_status()

Saya masih merekomendasikan untuk memberikan fungsionalitas asli perpustakaan, tetapi jika Anda mengalami masalah atau memerlukan kontrol yang lebih luas, backoff adalah sebuah opsi.

Cara yang lebih bersih untuk mendapatkan kontrol yang lebih tinggi mungkin untuk mengemas barang coba lagi ke dalam suatu fungsi dan membuat fungsi itu dapat dipulihkan menggunakan dekorator dan membuat daftar putih pengecualian.

Saya telah membuat yang sama di sini: http://www.praddy.in/retry-decorator-whitelisted-exceptions/

Mereproduksi kode di tautan itu:

def retry(exceptions, delay=0, times=2):
"""
A decorator for retrying a function call with a specified delay in case of a set of exceptions

Parameter List
-------------
:param exceptions:  A tuple of all exceptions that need to be caught for retry
                                    e.g. retry(exception_list = (Timeout, Readtimeout))
:param delay: Amount of delay (seconds) needed between successive retries.
:param times: no of times the function should be retried


"""
def outer_wrapper(function):
    @functools.wraps(function)
    def inner_wrapper(*args, **kwargs):
        final_excep = None  
        for counter in xrange(times):
            if counter > 0:
                time.sleep(delay)
            final_excep = None
            try:
                value = function(*args, **kwargs)
                return value
            except (exceptions) as e:
                final_excep = e
                pass #or log it

        if final_excep is not None:
            raise final_excep
    return inner_wrapper

return outer_wrapper

@retry(exceptions=(TimeoutError, ConnectTimeoutError), delay=0, times=3)
def call_api():