| import json |
| import logging |
| import queue |
| import random |
| import threading |
| import time |
|
|
| import requests |
| from bs4 import BeautifulSoup |
|
|
|
|
| class Proxy: |
| """Proxy class |
| |
| Attributes: |
| addr (str): A string with IP and port, for example '123.123.123.123:8080' |
| protocol (str): 'http' or 'https' |
| weight (float): A float point number indicating the probability of being |
| selected, the weight is based on the connection time and stability |
| last_checked (time): A UNIX timestamp indicating when the proxy was checked |
| """ |
|
|
| def __init__(self, addr=None, protocol="http", weight=1.0, last_checked=None): |
| self.addr = addr |
| self.protocol = protocol |
| self.weight = weight |
| if last_checked is None: |
| self.last_checked = int(time.time()) |
| else: |
| self.last_checked = last_checked |
|
|
| def format(self): |
| """Return the proxy compatible with requests.Session parameters |
| |
| Returns: |
| dict: A dict like {'http': '123.123.123.123:8080'} |
| """ |
| return {self.protocol: self.addr} |
|
|
| def to_dict(self): |
| """convert detailed proxy info into a dict |
| |
| Returns: |
| dict: A dict with four keys: ``addr``, ``protocol``, |
| ``weight`` and ``last_checked`` |
| """ |
| return dict(addr=self.addr, protocol=self.protocol, weight=self.weight, last_checked=self.last_checked) |
|
|
|
|
| class ProxyPool: |
| """Proxy pool class |
| |
| ProxyPool provides friendly apis to manage proxies. |
| |
| Attributes: |
| idx (dict): Index for http proxy list and https proxy list. |
| test_url (dict): A dict containing two urls, when testing if a proxy |
| is valid, test_url['http'] and test_url['https'] will be used |
| according to the protocol. |
| proxies (dict): All the http and https proxies. |
| addr_list (dict): Address of proxies. |
| dec_ratio (float): When decreasing the weight of some proxy, its weight |
| is multiplied with `dec_ratio`. |
| inc_ratio (float): Similar to `dec_ratio` but used for increasing |
| weights, default the reciprocal of `dec_ratio`. |
| weight_thr (float): The minimum weight of a valid proxy, if the weight |
| of a proxy is lower than `weight_thr`, it will be removed. |
| logger (Logger): A logging.Logger object used for logging. |
| """ |
|
|
| def __init__(self, filename=None): |
| """Init the pool from a json file. |
| |
| Args: |
| filename (str, optional): if the filename is provided, proxies |
| will be load from it. |
| |
| """ |
| self.idx = {"http": 0, "https": 0} |
| self.test_url = {"http": "http://www.sina.com.cn", "https": "https://www.taobao.com"} |
| self.proxies = {"http": {}, "https": {}} |
| self.addr_list = {"http": [], "https": []} |
| self.dec_ratio = 0.9 |
| self.inc_ratio = 1 / self.dec_ratio |
| self.weight_thr = 0.2 |
| self.logger = logging.getLogger(__name__) |
| if filename is not None: |
| self.load(filename) |
|
|
| def proxy_num(self, protocol=None): |
| """Get the number of proxies in the pool |
| |
| Args: |
| protocol (str, optional): 'http' or 'https' or None. (default None) |
| |
| Returns: |
| If protocol is None, return the total number of proxies, otherwise, |
| return the number of proxies of corresponding protocol. |
| """ |
| http_num = len(self.proxies["http"]) |
| https_num = len(self.proxies["https"]) |
| if protocol == "http": |
| return http_num |
| elif protocol == "https": |
| return https_num |
| else: |
| return http_num + https_num |
|
|
| def get_next(self, protocol="http", format=False, policy="loop"): |
| """Get the next proxy |
| |
| Args: |
| protocol (str): 'http' or 'https'. (default 'http') |
| format (bool): Whether to format the proxy. (default False) |
| policy (str): Either 'loop' or 'random', indicating the policy of |
| getting the next proxy. If set to 'loop', will return proxies |
| in turn, otherwise will return a proxy randomly. |
| |
| Returns: |
| Proxy or dict: If format is true, then return the formatted proxy |
| which is compatible with requests.Session parameters, |
| otherwise a Proxy object. |
| """ |
| if not self.proxies[protocol]: |
| return None |
| if policy == "loop": |
| idx = self.idx[protocol] |
| self.idx[protocol] = (idx + 1) % len(self.proxies[protocol]) |
| elif policy == "random": |
| idx = random.randint(0, self.proxy_num(protocol) - 1) |
| else: |
| self.logger.error(f"Unsupported get_next policy: {policy}") |
| exit() |
| proxy = self.proxies[protocol][self.addr_list[protocol][idx]] |
| if proxy.weight < random.random(): |
| return self.get_next(protocol, format, policy) |
| if format: |
| return proxy.format() |
| else: |
| return proxy |
|
|
| def save(self, filename): |
| """Save proxies to file""" |
| proxies = {"http": [], "https": []} |
| for protocol in ["http", "https"]: |
| for proxy in self.proxies[protocol]: |
| serializable_proxy = self.proxies[protocol][proxy].to_dict() |
| proxies[protocol].append(serializable_proxy) |
| with open(filename, "w") as fout: |
| json.dump(proxies, fout) |
|
|
| def load(self, filename): |
| """Load proxies from file""" |
| with open(filename) as fin: |
| proxies = json.load(fin) |
| for protocol in proxies: |
| for proxy in proxies[protocol]: |
| self.proxies[protocol][proxy["addr"]] = Proxy( |
| proxy["addr"], proxy["protocol"], proxy["weight"], proxy["last_checked"] |
| ) |
| self.addr_list[protocol].append(proxy["addr"]) |
|
|
| def add_proxy(self, proxy): |
| """Add a valid proxy into pool |
| |
| You must call `add_proxy` method to add a proxy into pool instead of |
| directly operate the `proxies` variable. |
| """ |
| protocol = proxy.protocol |
| addr = proxy.addr |
| if addr in self.proxies: |
| self.proxies[protocol][addr].last_checked = proxy.last_checked |
| else: |
| self.proxies[protocol][addr] = proxy |
| self.addr_list[protocol].append(addr) |
|
|
| def remove_proxy(self, proxy): |
| """Remove a proxy out of the pool""" |
| del self.search_flag[proxy.protocol][proxy.addr] |
| del self.addr_list[proxy.protocol][proxy.addr] |
|
|
| def increase_weight(self, proxy): |
| """Increase the weight of a proxy by multiplying inc_ratio""" |
| new_weight = proxy.weight * self.inc_ratio |
| if new_weight < 1.0: |
| proxy.weight = new_weight |
| else: |
| proxy.weight = 1.0 |
|
|
| def decrease_weight(self, proxy): |
| """Decreasing the weight of a proxy by multiplying dec_ratio""" |
| new_weight = proxy.weight * self.dec_ratio |
| if new_weight < self.weight_thr: |
| self.remove_proxy(proxy) |
| else: |
| proxy.weight = new_weight |
|
|
| def is_valid(self, addr, protocol="http", timeout=5): |
| """Check if a proxy is valid |
| |
| Args: |
| addr: A string in the form of 'ip:port' |
| protocol: Either 'http' or 'https', different test urls will be used |
| according to protocol. |
| timeout: A integer indicating the timeout of connecting the test url. |
| |
| Returns: |
| dict: If the proxy is valid, returns {'valid': True, 'response_time': xx} |
| otherwise returns {'valid': False, 'msg': 'xxxxxx'}. |
| """ |
| start = time.time() |
| try: |
| r = requests.get(self.test_url[protocol], timeout=timeout, proxies={protocol: "http://" + addr}) |
| except KeyboardInterrupt: |
| raise |
| except requests.exceptions.Timeout: |
| return {"valid": False, "msg": "timeout"} |
| except: |
| return {"valid": False, "msg": "exception"} |
| else: |
| if r.status_code == 200: |
| response_time = time.time() - start |
| return {"valid": True, "response_time": response_time} |
| else: |
| return {"valid": False, "msg": f"status code: {r.status_code}"} |
|
|
| def validate(self, proxy_scanner, expected_num=20, queue_timeout=3, val_timeout=5): |
| """Target function of validation threads |
| |
| Args: |
| proxy_scanner: A ProxyScanner object. |
| expected_num: Max number of valid proxies to be scanned. |
| queue_timeout: Timeout for getting a proxy from the queue. |
| val_timeout: An integer passed to `is_valid` as argument `timeout`. |
| """ |
| while self.proxy_num() < expected_num: |
| try: |
| candidate_proxy = proxy_scanner.proxy_queue.get(timeout=queue_timeout) |
| except queue.Empty: |
| if proxy_scanner.is_scanning(): |
| continue |
| else: |
| break |
| addr = candidate_proxy["addr"] |
| protocol = candidate_proxy["protocol"] |
| ret = self.is_valid(addr, protocol, val_timeout) |
| if self.proxy_num() >= expected_num: |
| self.logger.info(f"Enough valid proxies, thread {threading.current_thread().name} exit.") |
| break |
| if ret["valid"]: |
| self.add_proxy(Proxy(addr, protocol)) |
| self.logger.info("{} ok, {:.2f}s".format(addr, ret["response_time"])) |
| else: |
| self.logger.info("{} invalid, {}".format(addr, ret["msg"])) |
|
|
| def scan( |
| self, proxy_scanner, expected_num=20, val_thr_num=4, queue_timeout=3, val_timeout=5, out_file="proxies.json" |
| ): |
| """Scan and validate proxies |
| |
| Firstly, call the `scan` method of `proxy_scanner`, then using multiple |
| threads to validate them. |
| |
| Args: |
| proxy_scanner: A ProxyScanner object. |
| expected_num: Max number of valid proxies to be scanned. |
| val_thr_num: Number of threads used for validating proxies. |
| queue_timeout: Timeout for getting a proxy from the queue. |
| val_timeout: An integer passed to `is_valid` as argument `timeout`. |
| out_file: A string or None. If not None, the proxies will be saved |
| into `out_file`. |
| """ |
| try: |
| proxy_scanner.scan() |
| self.logger.info(f"starting {val_thr_num} threads to validating proxies...") |
| val_threads = [] |
| for i in range(val_thr_num): |
| t = threading.Thread( |
| name=f"val-{i + 1:0>2d}", |
| target=self.validate, |
| kwargs=dict( |
| proxy_scanner=proxy_scanner, |
| expected_num=expected_num, |
| queue_timeout=queue_timeout, |
| val_timeout=val_timeout, |
| ), |
| ) |
| t.daemon = True |
| val_threads.append(t) |
| t.start() |
| for t in val_threads: |
| t.join() |
| self.logger.info("Proxy scanning done!") |
| except: |
| raise |
| finally: |
| if out_file is not None: |
| self.save(out_file) |
|
|
| def default_scan( |
| self, |
| region="mainland", |
| expected_num=20, |
| val_thr_num=4, |
| queue_timeout=3, |
| val_timeout=5, |
| out_file="proxies.json", |
| src_files=None, |
| ): |
| """Default scan method, to simplify the usage of `scan` method. |
| |
| It will register following scan functions: |
| 1. scan_file |
| 2. scan_cnproxy (if region is mainland) |
| 3. scan_free_proxy_list (if region is overseas) |
| 4. scan_ip84 |
| 5. scan_mimiip |
| After scanning, all the proxy info will be saved in out_file. |
| |
| Args: |
| region: Either 'mainland' or 'overseas' |
| expected_num: An integer indicating the expected number of proxies, |
| if this argument is set too great, it may take long to |
| finish scanning process. |
| val_thr_num: Number of threads used for validating proxies. |
| queue_timeout: An integer indicating the timeout for getting a |
| candidate proxy from the queue. |
| val_timeout: An integer indicating the timeout when connecting the |
| test url using a candidate proxy. |
| out_file: the file name of the output file saving all the proxy info |
| src_files: A list of file names to scan |
| """ |
| if expected_num > 30: |
| self.logger.warn( |
| "The more proxy you expect, the more time it " |
| "will take. It is highly recommended to limit the" |
| " expected num under 30." |
| ) |
| proxy_scanner = ProxyScanner() |
| if src_files is None: |
| src_files = [] |
| elif isinstance(src_files, str): |
| src_files = [src_files] |
| for filename in src_files: |
| proxy_scanner.register_func(proxy_scanner.scan_file, {"src_file": filename}) |
| if region == "mainland": |
| proxy_scanner.register_func(proxy_scanner.scan_cnproxy, {}) |
| elif region == "overseas": |
| proxy_scanner.register_func(proxy_scanner.scan_free_proxy_list, {}) |
| proxy_scanner.register_func(proxy_scanner.scan_ip84, {"region": region, "page": 5}) |
| proxy_scanner.register_func(proxy_scanner.scan_mimiip, {"region": region, "page": 5}) |
| self.scan(proxy_scanner, expected_num, val_thr_num, queue_timeout, val_timeout, out_file) |
|
|
|
|
| class ProxyScanner: |
| """Proxy scanner class |
| |
| ProxyScanner focuses on scanning proxy lists from different sources. |
| |
| Attributes: |
| proxy_queue: The queue for storing proxies. |
| scan_funcs: Name of functions to be used in `scan` method. |
| scan_kwargs: Arguments of functions |
| scan_threads: A list of `threading.thread` object. |
| logger: A `logging.Logger` object used for logging. |
| """ |
|
|
| def __init__(self): |
| self.proxy_queue = queue.Queue() |
| self.scan_funcs = [] |
| self.scan_kwargs = [] |
| self.scan_threads = [] |
| self.logger = logging.getLogger(__name__) |
|
|
| def register_func(self, func_name, func_kwargs): |
| """Register a scan function |
| |
| Args: |
| func_name: The function name of a scan function. |
| func_kwargs: A dict containing arguments of the scan function. |
| """ |
| self.scan_funcs.append(func_name) |
| self.scan_kwargs.append(func_kwargs) |
|
|
| def scan_ip84(self, region="mainland", page=1): |
| """Scan candidate proxies from http://ip84.com |
| |
| Args: |
| region: Either 'mainland' or 'overseas'. |
| page: An integer indicating how many pages to be scanned. |
| """ |
| self.logger.info("start scanning http://ip84.com for proxy list...") |
| for i in range(1, page + 1): |
| if region == "mainland": |
| url = f"http://ip84.com/dlgn/{i}" |
| elif region == "overseas": |
| url = f"http://ip84.com/gwgn/{i}" |
| else: |
| url = f"http://ip84.com/gn/{i}" |
| response = requests.get(url) |
| soup = BeautifulSoup(response.content, "lxml") |
| table = soup.find("table", class_="list") |
| for tr in table.find_all("tr"): |
| if tr.th is not None: |
| continue |
| info = tr.find_all("td") |
| protocol = info[4].string.lower() |
| addr = f"{info[0].string}:{info[1].string}" |
| self.proxy_queue.put({"addr": addr, "protocol": protocol}) |
|
|
| def scan_mimiip(self, region="mainland", page=1): |
| """Scan candidate proxies from http://mimiip.com |
| |
| Args: |
| region: Either 'mainland' or 'overseas'. |
| page: An integer indicating how many pages to be scanned. |
| """ |
| self.logger.info("start scanning http://mimiip.com for proxy list...") |
| for i in range(1, page + 1): |
| if region == "mainland": |
| url = f"http://www.mimiip.com/gngao/{i}" |
| elif region == "overseas": |
| url = f"http://www.mimiip.com/hw/{i}" |
| else: |
| url = f"http://www.mimiip.com/gngao/{i}" |
| response = requests.get(url) |
| soup = BeautifulSoup(response.content, "lxml") |
| table = soup.find("table", class_="list") |
| for tr in table.find_all("tr"): |
| if tr.th is not None: |
| continue |
| info = tr.find_all("td") |
| protocol = info[4].string.lower() |
| addr = f"{info[0].string}:{info[1].string}" |
| self.proxy_queue.put({"addr": addr, "protocol": protocol}) |
|
|
| def scan_cnproxy(self): |
| """Scan candidate (mainland) proxies from http://cn-proxy.com""" |
| self.logger.info("start scanning http://cn-proxy.com for proxy list...") |
| response = requests.get("http://cn-proxy.com") |
| soup = BeautifulSoup(response.content, "lxml") |
| tables = soup.find_all("table", class_="sortable") |
| for table in tables: |
| for tr in table.tbody.find_all("tr"): |
| info = tr.find_all("td") |
| addr = f"{info[0].string}:{info[1].string}" |
| self.proxy_queue.put({"addr": addr, "protocol": "http"}) |
|
|
| def scan_free_proxy_list(self): |
| """Scan candidate (overseas) proxies from http://free-proxy-list.net""" |
| self.logger.info("start scanning http://free-proxy-list.net " "for proxy list...") |
| response = requests.get("http://free-proxy-list.net") |
| soup = BeautifulSoup(response.content, "lxml") |
| table = soup.find("table", id="proxylisttable") |
| for tr in table.tbody.find_all("tr"): |
| info = tr.find_all("td") |
| if info[4].string != "elite proxy": |
| continue |
| if info[6].string == "yes": |
| protocol = "https" |
| else: |
| protocol = "http" |
| addr = f"{info[0].string}:{info[1].string}" |
| self.proxy_queue.put({"addr": addr, "protocol": protocol}) |
|
|
| def scan_file(self, src_file): |
| """Scan candidate proxies from an existing file""" |
| self.logger.info(f"start scanning file {src_file} for proxy list...") |
| with open(src_file) as fin: |
| proxies = json.load(fin) |
| for protocol in proxies.keys(): |
| for proxy in proxies[protocol]: |
| self.proxy_queue.put({"addr": proxy["addr"], "protocol": protocol}) |
|
|
| def is_scanning(self): |
| """Return whether at least one scanning thread is alive""" |
| for t in self.scan_threads: |
| if t.is_alive(): |
| return True |
| return False |
|
|
| def scan(self): |
| """Start a thread for each registered scan function to scan proxy lists""" |
| self.logger.info( |
| "{0} registered scan functions, starting {0} threads " |
| "to scan candidate proxy lists...".format(len(self.scan_funcs)) |
| ) |
| for i in range(len(self.scan_funcs)): |
| t = threading.Thread( |
| name=self.scan_funcs[i].__name__, target=self.scan_funcs[i], kwargs=self.scan_kwargs[i] |
| ) |
| t.daemon = True |
| self.scan_threads.append(t) |
| t.start() |
|
|
