|
|
""" |
|
|
Proxy Handler Class |
|
|
""" |
|
|
import json |
|
|
from queue import Queue |
|
|
import time |
|
|
import urllib.parse |
|
|
import threading |
|
|
import requests |
|
|
|
|
|
class ThreadSafeDict(dict): |
|
|
""" |
|
|
Thread safe dict |
|
|
""" |
|
|
def __init__(self, *args, **kwargs): |
|
|
super().__init__(*args, **kwargs) |
|
|
self.lock = threading.Lock() |
|
|
def __getitem__(self, key): |
|
|
with self.lock: |
|
|
return super().__getitem__(key) |
|
|
def __setitem__(self, key, value): |
|
|
with self.lock: |
|
|
return super().__setitem__(key, value) |
|
|
def __delitem__(self, key): |
|
|
with self.lock: |
|
|
return super().__delitem__(key) |
|
|
def __contains__(self, key): |
|
|
with self.lock: |
|
|
return super().__contains__(key) |
|
|
def __len__(self): |
|
|
with self.lock: |
|
|
return super().__len__() |
|
|
def __iter__(self): |
|
|
with self.lock: |
|
|
return super().__iter__() |
|
|
def __repr__(self): |
|
|
with self.lock: |
|
|
return super().__repr__() |
|
|
def __str__(self): |
|
|
with self.lock: |
|
|
return super().__str__() |
|
|
|
|
|
class ProxyHandler: |
|
|
""" |
|
|
Sends request to http://{ip}:{port}/get_response_raw?url={url} with auth |
|
|
""" |
|
|
def __init__(self, proxy_list_file,proxy_auth="user:pass",port=80, wait_time=0.1,timeouts=10): |
|
|
self.proxy_auth = proxy_auth |
|
|
self.port = port |
|
|
self.proxy_list = [] |
|
|
self.commit_time = ThreadSafeDict() |
|
|
self.timeouts = timeouts |
|
|
self.wait_time = wait_time |
|
|
self.lock = threading.Lock() |
|
|
self.last_logged_activities = Queue(maxsize=100) |
|
|
with open(proxy_list_file, 'r', encoding='utf-8') as f: |
|
|
for line in f: |
|
|
self.proxy_list.append(line.strip()) |
|
|
for i, proxy in enumerate(self.proxy_list): |
|
|
if not proxy.startswith("http"): |
|
|
proxy = "http://" + proxy |
|
|
if ":" not in proxy: |
|
|
proxy += f":{self.port}" |
|
|
if not proxy.endswith("/"): |
|
|
proxy += "/" |
|
|
self.proxy_list[i] = proxy |
|
|
self.proxy_index = -1 |
|
|
def log_time(self): |
|
|
""" |
|
|
Logs the time |
|
|
""" |
|
|
self.last_logged_activities.put(time.time()) |
|
|
if self.last_logged_activities.full(): |
|
|
|
|
|
self.last_logged_activities.get() |
|
|
def get_average_time(self): |
|
|
""" |
|
|
Returns the average time |
|
|
""" |
|
|
|
|
|
if len(self.last_logged_activities.queue) > 1: |
|
|
return (self.last_logged_activities.queue[-1] - self.last_logged_activities.queue[0]) / self.last_logged_activities.qsize() |
|
|
return 0 |
|
|
def wait_until_commit(self, proxy_index=None): |
|
|
""" |
|
|
Waits until the commit time |
|
|
""" |
|
|
if proxy_index is None: |
|
|
proxy_index = self.proxy_index |
|
|
if proxy_index not in self.commit_time: |
|
|
self.commit_time[proxy_index] = 0 |
|
|
while time.time() < self.commit_time[proxy_index] + self.wait_time: |
|
|
time.sleep(0.01) |
|
|
self.commit_time[proxy_index] = time.time() |
|
|
def _update_proxy_index(self): |
|
|
""" |
|
|
Updates the proxy index |
|
|
""" |
|
|
with self.lock: |
|
|
self.proxy_index = (self.proxy_index + 1) % len(self.proxy_list) |
|
|
return self.proxy_index |
|
|
def get_response(self, url): |
|
|
""" |
|
|
Returns the response of the url |
|
|
""" |
|
|
url = urllib.parse.quote(url, safe='') |
|
|
try: |
|
|
index = self._update_proxy_index() |
|
|
self.wait_until_commit(index) |
|
|
self.log_time() |
|
|
response = requests.get(self.proxy_list[index] + f"get_response?url={url}", timeout=self.timeouts, auth=tuple(self.proxy_auth.split(":"))) |
|
|
if response.status_code == 200: |
|
|
json_response = response.json() |
|
|
if json_response["success"]: |
|
|
return json.loads(json_response["response"]) |
|
|
else: |
|
|
if "429" in json_response["response"]: |
|
|
self.commit_time[index] = time.time() + self.timeouts |
|
|
print(f"Error: {json_response['response']}, waiting {self.timeouts} seconds") |
|
|
print(f"Failed in proxy side: {json_response['response']}") |
|
|
return None |
|
|
elif response.status_code == 429: |
|
|
self.commit_time[index] = time.time() + self.timeouts |
|
|
print(f"Error: {response.status_code}, waiting {self.timeouts} seconds") |
|
|
else: |
|
|
print(f"Failed in proxy side: {response.status_code}") |
|
|
return None |
|
|
except Exception as e: |
|
|
print(f"Error while processing response from proxy: {e}") |
|
|
return None |
|
|
def get(self, url): |
|
|
""" |
|
|
Returns the response of the url |
|
|
""" |
|
|
url = urllib.parse.quote(url, safe='') |
|
|
try: |
|
|
index = self._update_proxy_index() |
|
|
self.wait_until_commit(index) |
|
|
response = requests.get(self.proxy_list[index] + f"get_response_raw?url={url}", timeout=self.timeouts, auth=tuple(self.proxy_auth.split(":"))) |
|
|
if response.status_code == 200: |
|
|
return response |
|
|
else: |
|
|
print(f"Error: {response.status_code}") |
|
|
return None |
|
|
except Exception as e: |
|
|
print(f"Exception: {e}") |
|
|
return None |
|
|
def filesize(self, url): |
|
|
""" |
|
|
Returns the filesize of the url |
|
|
""" |
|
|
url = urllib.parse.quote(url, safe='') |
|
|
try: |
|
|
index = self._update_proxy_index() |
|
|
self.wait_until_commit(index) |
|
|
response = requests.get(self.proxy_list[index] + f"file_size?url={url}", timeout=self.timeouts, auth=tuple(self.proxy_auth.split(":"))) |
|
|
if response.status_code == 200: |
|
|
return int(response.text) |
|
|
else: |
|
|
print(f"Error: {response.status_code} when getting filesize from {url}") |
|
|
return None |
|
|
except Exception as e: |
|
|
print(f"Exception: {e}") |
|
|
return None |
|
|
def get_filepart(self, url, start, end): |
|
|
""" |
|
|
Returns the response of the url with range |
|
|
""" |
|
|
url = urllib.parse.quote(url, safe='') |
|
|
try: |
|
|
index = self._update_proxy_index() |
|
|
self.wait_until_commit(index) |
|
|
response = requests.get(self.proxy_list[index] + f"filepart?url={url}&start={start}&end={end}", timeout=self.timeouts, auth=tuple(self.proxy_auth.split(":"))) |
|
|
if response.status_code == 200: |
|
|
return response |
|
|
else: |
|
|
print(f"Error: {response.status_code}") |
|
|
return None |
|
|
except Exception as e: |
|
|
print(f"Exception: {e}") |
|
|
return None |
|
|
def check(self,raise_exception=False): |
|
|
""" |
|
|
Checks if the proxies are working |
|
|
""" |
|
|
failed_proxies = [] |
|
|
for i, proxy in enumerate(self.proxy_list): |
|
|
try: |
|
|
response = requests.get(proxy, auth=tuple(self.proxy_auth.split(":")), timeout=2) |
|
|
if response.status_code == 200: |
|
|
continue |
|
|
else: |
|
|
print(f"Proxy {proxy} is not working") |
|
|
failed_proxies.append(i) |
|
|
except Exception as e: |
|
|
print(f"Proxy {proxy} is not working: {e}") |
|
|
failed_proxies.append(i) |
|
|
if len(failed_proxies) > 0: |
|
|
if raise_exception: |
|
|
raise Exception(f"Proxies {failed_proxies} are not working") |
|
|
else: |
|
|
print(f"Proxies {failed_proxies} are not working, total {len(failed_proxies)} proxies of {len(self.proxy_list)} are not working") |
|
|
|
|
|
for i in failed_proxies[::-1]: |
|
|
del self.proxy_list[i] |
|
|
if len(self.proxy_list) == 0: |
|
|
raise Exception("No proxies available") |
|
|
else: |
|
|
print(f"All {len(self.proxy_list)} proxies are working") |
|
|
|
|
|
class SingleProxyHandler(ProxyHandler): |
|
|
""" |
|
|
Sends request to http://{ip}:{port}/get_response_raw?url={url} with auth |
|
|
""" |
|
|
def __init__(self, proxy_url, proxy_auth="user:pass",port=80, wait_time=0.1,timeouts=10): |
|
|
self.proxy_auth = proxy_auth |
|
|
self.port = port |
|
|
self.proxy_list = [proxy_url] |
|
|
self.proxy_index = -1 |
|
|
self.commit_time = ThreadSafeDict() |
|
|
self.timeouts = timeouts |
|
|
self.wait_time = wait_time |
|
|
self.lock = threading.Lock() |
|
|
|
