def get_redirect_url(self, *args, **kwargs): """ Redirects user to relative social auth provider for logout process. In-case no auth provider is found or the logout_url is missing in provider's configurations the user is redirected to edX's default logout page '/logout' """ backend_name = getattr(settings, 'COLARAZ_AUTH_PROVIDER_BACKEND_NAME', None) if third_party_auth.is_enabled( ) and backend_name and self.request.session.has_key('id_token'): provider = [ enabled for enabled in third_party_auth.provider.Registry.enabled() if enabled.backend_name == backend_name ] if provider: logout_url = json.loads( getattr(provider[0], 'other_settings', '{}')).get('logout_url') if logout_url: redirect_to = self.request.META.get( 'HTTP_REFERER') or get_site_base_url(self.request) params = { 'id_token_hint': self.request.session['id_token'], 'post_logout_redirect_uri': redirect_to } req = PreparedRequest() req.prepare_url(logout_url, params) return req.url return reverse('logout')
def _call_api(self, method, path, params=None, data=None): """Execute an API request. Arguments: method (str): HTTP request type path (str): API request path data (dict): Data to send in dictionary format Returns: Response: The requests response object """ url = 'https://{}/api/{}'.format(self._host, path) if params: req = PreparedRequest() req.prepare_url(url, params) url = req.url if self._session is None: self.connect() response = self._session.request(method=method, url=url, json=data, verify=self._verify_ssl, timeout=self._timeout) try: response.raise_for_status() return response # TODO CHECK FOR TOKEN EXPIRATION except Exception as exception: raise exception
def test_prepared_copy(kwargs): p = PreparedRequest() if kwargs: p.prepare(**kwargs) copy = p.copy() for attr in ('method', 'url', 'headers', '_cookies', 'body', 'hooks'): assert getattr(p, attr) == getattr(copy, attr)
def _call_api(self, http_func, host, path, data, headers, timeout=None): url = "{host}{path}".format(host=host, path=path) begin = time.time() # add extra params in url if not empty if self._extra_url_params: preReq = PreparedRequest() preReq.prepare_url(url, self._extra_url_params) url = preReq.url ok, message, _data = http_func(url, data, headers=headers, timeout=timeout) if logger.isEnabledFor(logging.DEBUG): logger.debug("do http request: method=`%s`, url=`%s`, data=`%s`", http_func.__name__, url, json.dumps(data)) logger.debug( "http request result: ok=`%s`, message=`%s`, _data=`%s`", ok, message, json.dumps(_data)) logger.debug("http request took %s ms", int((time.time() - begin) * 1000)) if not ok: return False, message or "verify from iam server fail", None if _data.get("code") != 0: return False, _data.get("message") or "iam api fail", None _d = _data.get("data") return True, "ok", _d
def getAthleteName(name): name = name.replace(" ", "_") request = PreparedRequest() request.prepare_url("https://en.wikipedia.org/wiki/", name) url_link = "https://en.wikipedia.org/wiki/" + name return name, url_link
def _get_response(self, url, data): req = PreparedRequest() req.prepare_url(url, data) result = requests.get(unquote(req.url)).content logging.warn('-getresponse') logging.warn(result) return True
def send_reset_email(user, token): # user = user_service.get_a_user(public_id) req = PreparedRequest() host = request.host_url req.prepare(url=f'{host}password_reset', params={ 'user': user.public_id, 'auth': token }) if current_app.config['TESTING']: return req.url file = rel_path('../util/password-reset.html', __file__) with open(file) as f: html_template = Template(f.read()) html = html_template.render( link=req.url, host=host, header='Reset Your Password', name=user.name_first, body="Tap the button below to reset your password. " "If you didn't request a new password, you can safely delete this email.", button_text="Reset Password", ) email_text = MIMEText(html, 'html') send_email(user.email, email_text, "Reset your password") if current_app.config['DEBUG']: return req.url
def confirm_sign_up(): from chalicelib.main import app, USER_POOL_ID, COGNITO_CLIENT_ID confirmation_code = app.current_request.query_params["code"] username = app.current_request.query_params["username"] user = cognito_idp_client.admin_get_user(UserPoolId=USER_POOL_ID, Username=username) redirect_url = "http://chinmayamission.com" for attribute in user["UserAttributes"]: if attribute["Name"] == "website": redirect_url = attribute["Value"] try: # Exceptions: https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_ConfirmSignUp.html cognito_idp_client.confirm_sign_up( ClientId=COGNITO_CLIENT_ID, Username=username, ConfirmationCode=confirmation_code, ) except Exception as e: params = { "confirmSignupErrorMessage": e.response["Error"]["Message"], "confirmSignupErrorCode": e.response["Error"]["Code"], } # Use PreparedRequest so it preserves the existing query string in redirect_url req = PreparedRequest() req.prepare_url(redirect_url, params) return Response(status_code=302, body="", headers={"Location": req.url}) return Response(status_code=302, body="", headers={"Location": redirect_url})
def f( method="GET", url="http://mockapi.com", headers=None, files=None, data=None, params=None, auth=None, cookies=None, hooks=None, json=None, ) -> PreparedRequest: request = PreparedRequest() request.prepare( method=method, url=url, headers=headers, files=files, data=data, params=params, auth=auth, cookies=cookies, hooks=hooks, json=json, ) return request
def generate_form_link(pid, account, amount, comment): """ Создание автозаполненной платежной формы Parameters ---------- pid : str ID провайдера account : str Счет получателя amount : float Сумма платежа comment : str Комментарий Returns ------- str Ссылка """ url = "https://qiwi.com/payment/form/{0}".format(pid) params = {"currency": 643} if type(amount) == float: params['amountInteger'] = str(amount).split('.')[0] params['amountFraction'] = str(amount).split('.')[1] else: params['amountInteger'] = amount from urllib.parse import urlencode if comment: params['comment'] = urlencode(comment) if account: params['account'] = urlencode(account) return PreparedRequest().prepare_url(url, params).url
def _search(query: str): url = "https://www.googleapis.com/youtube/v3/search" results = [] params = {'key': token, 'part': 'snippet', 'q': query, 'maxResults': 15} req = PreparedRequest() req.prepare_url(url, params) json = requests.get(req.url).json() ids = [] for item in json['items']: videoId = item['id'].get('videoId') playlistId = item['id'].get('playlistId') if (not videoId and not playlistId): continue results.append({ 'id': videoId if videoId != None else playlistId, 'title': html.unescape(item['snippet']['title']), 'isPlaylist': playlistId != None }) if (videoId): ids.append(videoId) durations = get_video_durations(ids) for i in range(len(results)): item = results[i] if (not item['isPlaylist']): item['duration'] = durations[item['id']] return results
def send_verify_email(user, token): req = PreparedRequest() host = request.host_url req.prepare(url=f'{host}verify', params={ 'user': user.public_id, 'auth': token }) if current_app.config['TESTING']: return req.url file = rel_path('../util/password-reset.html', __file__) with open(file) as f: html_template = Template(f.read()) html = html_template.render( link=req.url, host=host, header='Verify Your Account', name=user.name_first, body= "Tap the button below to verify your account, the link expires within 30 minutes.", button_text="Verify Account", ) email_text = MIMEText(html, 'html') send_email(user.email, email_text, "Verify your account") if current_app.config['DEBUG']: return req.url
def search(): meta = get_meta() filters = get_filters() # get counts count_total = query(count_all=True) count_filtered = query(filters=filters, count_filtered=True) # build response results = query(meta=meta, filters=filters) headers = { "Query-Count-Total": str(count_total), "Query-Count-Filtered": str(count_filtered), "Cache-Control": "max-age=259200", "Access-Control-Expose-Headers": "Query-Count-Total, Query-Count-Filtered, Query-Next" } if count_filtered > meta["page"] * meta["limit"]: next_url_params = { 'page': str(meta["page"] + 1), 'page_size': str(meta["limit"]), 'order_by': meta["order_by"], 'order_by_direction': meta["order_by_direction"] } next_url_params.update(filters) next_request = PreparedRequest() next_request.prepare_url(request.base_url, next_url_params) headers['Query-Next'] = next_request.url return Response(result_generator(results), headers=[(k, v) for k, v in headers.iteritems()], mimetype='text/csv')
def check_url(url): prepared_request = PreparedRequest() try: prepared_request.prepare_url(url, None) return True except requests.exceptions.MissingSchema: return False
def is_valid_url(url): prepared_request = PreparedRequest() try: prepared_request.prepare_url(url, None) return True except Exception as e: return False
def test_prepared_request_no_cookies_copy(): p = PreparedRequest() p.prepare(method='GET', url='http://www.example.com', data='foo=bar', hooks=default_hooks()) assert_copy(p, p.copy())
def scrapeYahoo(season, week, position): url = 'https://football.fantasysports.yahoo.com/f1/47241/players' drop_cols = [ 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 13, 17, 19, 20, 24, 25, 30, 31, 32, 33, 34, 35, 36, 37 ] col_names = [ 'name', 'pass_att', 'pass_comp', 'pass_yds', 'pass_td', 'pass_int', 'pass_sack', 'rush_att', 'rush_yds', 'rush_td', 'rec_tgt', 'rec_rec', 'rec_yds', 'rec_td' ] all_players = pd.DataFrame(columns=col_names) for count in range(0, 300, 25): querystring = { 'sort': 'PTS', 'sdir': '1', 'status': 'A', 'pos': '{}'.format(position), 'stat1': 'S_PW_{}'.format(week), 'jsenabled': '0', 'count': '{}'.format(count) } req = PreparedRequest() req.prepare_url(url, querystring) tables = pd.read_html(req.url) players = tables[1] players.drop(players.columns[drop_cols], axis=1, inplace=True) players.columns = col_names players['name'] = players['name'].apply(name_cleanup) if len(players) == 0: break all_players = all_players.append(players, ignore_index=True) return all_players
def drop_params_from_url(url, params, drop_keys, assert_param_is_present=False): out_url = "" try: pre_req = PreparedRequest() pre_req.prepare_url(url, params) u = urlparse(pre_req.url) current_params = parse_qs(u.query) if assert_param_is_present: keys_diff = set(drop_keys) - set(current_params) assert keys_diff == set(), f"Keys not present : {keys_diff}" final_params = { k: v for k, v in current_params.items() if k not in drop_keys } current_url = u._replace(params="")._replace(query="")._replace( fragment="").geturl() pre_req.prepare_url(current_url, final_params) out_url = pre_req.url except Exception as e: print(f"\n Exception occured: {e}!! \n URL: {url} \n PARAMS: {params}") return out_url
def addParamsToUrl(self, url: str, params: dict) -> str: """ Belirtilen parametreleri adrese ekler. """ req = PreparedRequest() req.prepare_url(url, params) return req.url
def append_params_to_url(DO_WE_ADD_PARAMS_REUPLOAD, url): ## Used for appending random strings as query parameters to URLS in the reposting module. This gives a unique variation of the URL. if DO_WE_ADD_PARAMS_REUPLOAD: params = {random_char(5):random_char(5)} req = PreparedRequest() req.prepare_url(url, params) return req.url else: return url
def apipara(a): req = PreparedRequest() url = "http://integra-net4/BMJ_ICE_Test/assignjob" params = {'ID': a} req.prepare_url(url, params) content = urllib.request.urlopen(req.url).read() data = json.loads(content) return data['success'], data['msg']
def get_screenshot( self, url: str, element_name: str, user: "******", ) -> Optional[bytes]: params = {"standalone": DashboardStandaloneMode.REPORT.value} req = PreparedRequest() req.prepare_url(url, params) url = req.url or "" driver = self.auth(user) driver.set_window_size(*self._window) driver.get(url) img: Optional[bytes] = None selenium_headstart = current_app.config[ "SCREENSHOT_SELENIUM_HEADSTART"] logger.debug("Sleeping for %i seconds", selenium_headstart) sleep(selenium_headstart) try: logger.debug("Wait for the presence of %s", element_name) element = WebDriverWait(driver, self._screenshot_locate_wait).until( EC.presence_of_element_located( (By.CLASS_NAME, element_name))) logger.debug("Wait for .loading to be done") WebDriverWait(driver, self._screenshot_load_wait).until_not( EC.presence_of_all_elements_located( (By.CLASS_NAME, "loading"))) logger.debug("Wait for chart to have content") WebDriverWait(driver, self._screenshot_locate_wait).until( EC.visibility_of_all_elements_located( (By.CLASS_NAME, "slice_container"))) selenium_animation_wait = current_app.config[ "SCREENSHOT_SELENIUM_ANIMATION_WAIT"] logger.debug("Wait %i seconds for chart animation", selenium_animation_wait) sleep(selenium_animation_wait) logger.info("Taking a PNG screenshot of url %s", url) img = element.screenshot_as_png except TimeoutException: logger.warning("Selenium timed out requesting url %s", url, exc_info=True) img = element.screenshot_as_png except StaleElementReferenceException: logger.error( "Selenium got a stale element while requesting url %s", url, exc_info=True, ) except WebDriverException as ex: logger.error(ex, exc_info=True) finally: self.destroy(driver, current_app.config["SCREENSHOT_SELENIUM_RETRIES"]) return img
def prepare_param_discovery_urls(self, base_url): """ For given URL generates bunch of parameter discovery URLs with canaries and returns this information back. """ PARAM_SEP_LEN = 2 CANARY_LEN = self.CANARY_LENGTH url_len = len(base_url) discovery_urls = [] param_dict = {} canary_dict = {} try: with open('payloads/parameters.txt', 'r') as f: param_list = f.read().splitlines() self.url_discovery_parameters = param_list except IOError as e: self.mprint("[ERROR] Unable to open payloads/parameters.txt.") self.fprint(e) return for param in param_list: if (url_len + len(param) + PARAM_SEP_LEN + CANARY_LEN) < self.MAX_ACCEPTED_URL_LENGTH: # URL Character limit not exceeded yet. canary = utils.get_rnd_string(CANARY_LEN) param_dict[param] = canary canary_dict[param] = canary url_len += (PARAM_SEP_LEN + len(param) + CANARY_LEN) else: # Add to URLs, start preparing a new one. r = PreparedRequest() r.prepare_url(base_url, param_dict) discovery_urls.append(r.url) param_dict = {} url_len = len(base_url) # Leftovers after depleting all parameters from paramlist. if len(param_dict) != 0: r = PreparedRequest() r.prepare_url(base_url, param_dict) discovery_urls.append(r.url) return (discovery_urls, canary_dict)
def add_params_to_url(url, params): out_url = "" try: req = PreparedRequest() req.prepare_url(url, params) out_url = req.url except Exception as e: print(f"\n Exception occured: {e}!! \n URL: {url} \n PARAMS: {params}") return out_url
def check_url(url): prepared_request = PreparedRequest( ) # create an instance of the PreparedRequest class of the requests library try: prepared_request.prepare_url(url, None) # checking for the correct of url return True except: return False
def apipara(a): req = PreparedRequest() url = "any url" params = {'ID':a} req.prepare_url(url, params) content = urllib.request.urlopen(req.url).read() data = json.loads(content) print(data['success'])#I Extract json content print(data['msg'])#I Extract json content
def validate_url(text: str): """ Validates a URL. """ prepared_request = PreparedRequest() try: prepared_request.prepare_url(text, None) return True except MissingSchema: return False
def session_check(session_id): if 'uuid' in session and session['uuid'] == session_id: session['valid'] = True return redirect(request.args.get('follow'), code=307) else: follow_url = request.args.get('follow') req = PreparedRequest() req.prepare_url(follow_url, {'cookies_disabled': 1}) session.pop('_permanent', None) return redirect(req.url, code=307)
def test_data_argument_accepts_tuples(data): """Ensure that the data argument will accept tuples of strings and properly encode them. """ p = PreparedRequest() p.prepare(method='GET', url='http://www.example.com', data=data, hooks=default_hooks()) assert p.body == urlencode(data)
def get_order_requirements( did: str, service_endpoint: str, consumer_address: str, service_id: Union[str, int], service_type: str, token_address: str, userdata: Optional[Dict] = None, ) -> Optional[OrderRequirements]: """ :param did: :param service_endpoint: :param consumer_address: hex str the ethereum account address of the consumer :param service_id: :param service_type: :param token_address: :return: OrderRequirements instance -- named tuple (amount, data_token_address, receiver_address, nonce), """ req = PreparedRequest() params = { "documentId": did, "serviceId": service_id, "serviceType": service_type, "dataToken": token_address, "consumerAddress": consumer_address, } if userdata: userdata = json.dumps(userdata) params["userdata"] = userdata req.prepare_url(service_endpoint, params) initialize_url = req.url logger.info(f"invoke the initialize endpoint with this url: {initialize_url}") response = DataServiceProvider._http_method("get", initialize_url) # The returned json should contain information about the required number of tokens # to consume `service_id`. If service is not available there will be an error or # the returned json is empty. if response.status_code != 200: return None order = dict(response.json()) return OrderRequirements( to_wei( Decimal(order["numTokens"]) ), # comes as float, needs to be converted order["dataToken"], order["to"], int(order["nonce"]), order.get("computeAddress"), )