ഓരോ 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-ന് പുതിയ പരിമിതമായ ശ്രമം സൃഷ്ടിക്കണം. പങ്കിട്ട പട്ടികയിൽ നിന്ന് എൻട്രികൾ നീക്കം ചെയ്യുന്ന ആവർത്തന വീണ്ടും-ശ്രമിക്കൽ വിളികൾ ഒഴിവാക്കുക: മറ്റൊരു തൊഴിലാളി അതിൽ നിന്ന് തിരഞ്ഞെടുക്കുന്നുണ്ടാകാം, തീർന്ന പട്ടികയ്ക്ക് ഇപ്പോഴും വ്യക്തമായ ഫലം ആവശ്യമാണ്.