ಸಮಕಾಲೀನ urllib3 ಪ್ರಾಕ್ಸಿ ವಿನಂತಿಗಳಿಂದ ಪ್ರತಿ ಫಲಿತಾಂಶವನ್ನು ಸಂಗ್ರಹಿಸಿ

ಕೆಲಸಗಾರ ಪೂಲ್ ರಚಿಸುವುದು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿದ ಪುಟಗಳನ್ನು ಕರೆಗಾರನಿಗೆ ನೀಡುವುದಿಲ್ಲ. ಸಲ್ಲಿಸಿದ ಕೆಲಸವು ಹಿಂತಿರುಗಿಸುವ ಮೌಲ್ಯಗಳನ್ನು ಇರಿಸಿಕೊಳ್ಳಿ ಮತ್ತು ಬಳಸಿ:

from concurrent.futures import ThreadPoolExecutor
import urllib3

manager = urllib3.ProxyManager(
    'http://proxy.example:8080',
    maxsize=4,
    block=True,
)

def fetch(url):
    response = manager.request(
        'GET', url, timeout=urllib3.Timeout(connect=5, read=15),
    )
    return url, response.status, response.data

try:
    with ThreadPoolExecutor(max_workers=4) as workers:
        results = list(workers.map(fetch, urls))
finally:
    manager.clear()

ಈ ತುಣುಕು ಸೀಮಿತ URL ಪಟ್ಟಿ ಮತ್ತು ಸಾಮಾನ್ಯ ಪ್ರತಿಕ್ರಿಯೆ ಗಾತ್ರಗಳನ್ನು ಊಹಿಸುತ್ತದೆ. ಪ್ರಾಕ್ಸಿ ದೃಢೀಕರಣವಿಲ್ಲದೆ ಅನುಮತಿಸಲಾದ ಸಾರ್ವಜನಿಕ-URL ಪರಿಶೀಲನೆಗಳಿಗೆ HTTP ಪ್ರಾಕ್ಸಿ ಪಟ್ಟಿಯಿಂದ ಅಭ್ಯರ್ಥಿಯು ನಿರ್ವಾಹಕರ ಉದಾಹರಣೆ HTTP ಎಂಡ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ಬದಲಾಯಿಸಬಹುದು. ಪ್ರತಿ ಫಲಿತಾಂಶವು ತನ್ನ URL ಅನ್ನು ಒಳಗೊಂಡಿದೆ, ಇದರಿಂದ ಕರೆಗಾರನು ಸ್ಥಿತಿ ಮತ್ತು ದೇಹವನ್ನು ಸರಿಯಾದ ವಿನಂತಿಗೆ ಸಂಯೋಜಿಸಬಹುದು. map ಒಳಹರಿವಿನ ಕ್ರಮದಲ್ಲಿ ಫಲಿತಾಂಶಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ; ಕೆಲಸಗಾರನಲ್ಲಿನ ಅಪವಾದವು ಆ ಫಲಿತಾಂಶವನ್ನು ಪಡೆದಾಗ ಎತ್ತಲ್ಪಡುತ್ತದೆ.

ಸಂರಚಿತ ProxyManager ವಿನಂತಿಗಳಿಗೆ ಸಂಪರ್ಕ ಪೂಲಿಂಗ್ ಅನ್ನು ಹೊಂದಿದೆ. ಇಲ್ಲಿ ಬಳಸಿದ ಡೀಫಾಲ್ಟ್ ಪೂರ್ವಲೋಡ್ ಮಾಡಿದ ಪ್ರತಿಕ್ರಿಯೆ ಮೋಡ್‌ನೊಂದಿಗೆ, urllib3 ದೇಹವನ್ನು ಓದಿ ಸಂಪರ್ಕವನ್ನು ತನ್ನ ಪೂಲ್‌ಗೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಸ್ಟ್ರೀಮಿಂಗ್ ಆವೃತ್ತಿಗೆ ಸ್ಪಷ್ಟ ಬಳಕೆ ಮತ್ತು ಸಂಪರ್ಕ ಬಿಡುಗಡೆ ಅಗತ್ಯವಿರುತ್ತದೆ.

maxsize ಸಾಮಾನ್ಯವಾಗಿ ಉಳಿಸಿಕೊಂಡ ಮರುಬಳಕೆ ಸಂಪರ್ಕಗಳನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ, ಪ್ರತಿ ತೆರೆದ ಸಾಕೆಟ್‌ನಲ್ಲಿ ಕಠಿಣ ಮಿತಿಯಲ್ಲ. block=True ಸಂಬಂಧಿತ ಪೂಲ್ ವರ್ತನೆಯನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ, ಇದರಿಂದ ಕರೆಗಾರರು ಆ ಪೂಲ್ ಮಿತಿಯನ್ನು ಮೀರಿ ಹೆಚ್ಚುವರಿ ತೆರೆಯುವ ಬದಲು ಮುಕ್ತ ಸಂಪರ್ಕಕ್ಕಾಗಿ ಕಾಯುತ್ತಾರೆ.

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ಕೆಲಸಗಾರರ ಸಂಖ್ಯೆ ಸಮಕಾಲೀನ ಕರೆಗಳನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತದೆ. ಅನೇಕ ಗಮ್ಯಸ್ಥಾನಗಳೊಂದಿಗೆ, ಪೂಲ್ ಜೋಡಣೆ ಮತ್ತು HTTPS ಸುರಂಗಗಳಿಗೆ ಬಳಸುವ ಮಾರ್ಗವೂ ಮುಖ್ಯ; ಒಂದು ಪೂಲ್‌ನ ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ಪ್ರತಿ ಹೋಸ್ಟ್‌ಗೆ ಒಂದು ಜಾಗತಿಕ ಸಾಕೆಟ್ ಕೋಟಾ ಎಂದು ವಿವರಿಸಬಾರದು.