દરેક Python ThreadPoolExecutor કાર્યને URL અને પ્રોક્સી સોંપો

પૂલનું map એક સમયે એક આઇટમ કાર્યકર્તાને પસાર કરે છે. તે આઇટમને સંપૂર્ણ કાર્ય બનાવો, URL અને પસંદ કરેલી પ્રોક્સી સહિત, જેથી કાર્યકર્તા બદલાતી વૈશ્વિક સૂચિમાંથી તેનો માર્ગ અનુમાન ન કરે.

મર્યાદિત urls માટે, માન્ય પ્રોક્સી URL ની ખાલી ન હોય તેવી સૂચિ આપો. જાહેર HTTP ઉમેદવારો HTTP પ્રોક્સી સૂચિ માં ઉપલબ્ધ છે:

from concurrent.futures import ThreadPoolExecutor
from itertools import cycle
import requests

def fetch(job):
    url, proxy_url = job
    proxies = {"http": proxy_url, "https": proxy_url}
    with requests.get(url, proxies=proxies, timeout=(5, 15)) as response:
        response.raise_for_status()
        return url, response.text

if not proxy_urls:
    raise ValueError("No proxy endpoints were supplied")

jobs = zip(urls, cycle(proxy_urls))
with ThreadPoolExecutor(max_workers=5) as executor:
    for url, body in executor.map(fetch, jobs):
        handle_result(url, body)

urls, proxy_urls અને handle_result એપ્લિકેશન દ્વારા પ્રદાન કરવામાં આવે છે. સંકલક પુનરાવર્તિત ક્રમમાં એન્ડપોઇન્ટ સોંપે છે; દરેક કાર્યકર્તાને એક નિશ્ચિત જોડી મળે છે. પરિણામોનું પુનરાવર્તન કાર્યકર્તાના અપવાદોને પણ પ્રગટ કરે છે.

પાંચ કાર્યકર્તા સક્રિય કાર્યોને મર્યાદિત કરે છે, પ્રતિ પ્રોક્સી સક્રિય કાર્યોને નહીં. જો સૂચિમાં બે એન્ડપોઇન્ટ હોય, તો ઘણાં કાર્યો એક જ એન્ડપોઇન્ટનો એકસાથે ઉપયોગ કરી શકે છે. જ્યારે જરૂરી હોય ત્યારે પ્રતિ એન્ડપોઇન્ટ અલગ ક્ષમતા નિયમ ઉમેરો. પ્રતિ એન્ડપોઇન્ટ URL એક સક્રિય કાર્ય માટે, સિંક્રોનાઇઝ્ડ ક્યૂ ભાડું દરેક એન્ટ્રી અનામત રાખી શકે અને પરત આપી શકે.

પુનઃપ્રયાસે એ જ URL માટે નવો મર્યાદિત પ્રયાસ બનાવવો જોઈએ. વિભાજિત સૂચિમાંથી એન્ટ્રી દૂર કરતા પુનરાવર્તી પુનઃપ્રયાસ કૉલ્સ ટાળો: બીજો કાર્યકર્તા તેમાંથી પસંદ કરી રહ્યો હોઈ શકે છે, અને ખાલી થયેલી સૂચિને હજી સ્પષ્ટ પરિણામની જરૂર છે.