ಪ್ರತಿ 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 ಗೆ ಹೊಸ ಸೀಮಿತ ಪ್ರಯತ್ನವನ್ನು ರಚಿಸಬೇಕು. ಹಂಚಿಕೆಯ ಪಟ್ಟಿಯಿಂದ ನಮೂದುಗಳನ್ನು ತೆಗೆದುಹಾಕುವ ಪುನರಾವರ್ತಿತ ಮರುಪ್ರಯತ್ನ ಕರೆಗಳನ್ನು ತಪ್ಪಿಸಿ: ಇನ್ನೊಬ್ಬ ಕೆಲಸಗಾರ ಅದರಿಂದ ಆಯ್ಕೆ ಮಾಡುತ್ತಿರಬಹುದು, ಮತ್ತು ಖಾಲಿಯಾದ ಪಟ್ಟಿಗೆ ಇನ್ನೂ ಸ್ಪಷ್ಟ ಫಲಿತಾಂಶ ಬೇಕು.