ਹਰ 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 ਲਈ ਨਵੀਂ ਸੀਮਿਤ ਕੋਸ਼ਿਸ਼ ਬਣਾਉਣੀ ਚਾਹੀਦੀ ਹੈ। ਸਾਂਝੀ ਸੂਚੀ ਤੋਂ ਐਂਟਰੀਆਂ ਹਟਾਉਣ ਵਾਲੀਆਂ ਦੁਹਰਾਉਂਦੀਆਂ ਦੁਬਾਰਾ-ਕੋਸ਼ਿਸ਼ ਕਾਲਾਂ ਤੋਂ ਬਚੋ: ਹੋ ਸਕਦਾ ਹੈ ਕੋਈ ਹੋਰ ਕਾਮਾ ਉਸ ਵਿੱਚੋਂ ਚੁਣ ਰਿਹਾ ਹੋਵੇ, ਅਤੇ ਖ਼ਤਮ ਹੋਈ ਸੂਚੀ ਨੂੰ ਅਜੇ ਵੀ ਸਪਸ਼ਟ ਨਤੀਜਾ ਚਾਹੀਦਾ ਹੈ।