def request(self, method, uri, access_token=None, **kwargs): """Sends a request to an OAuth 2.0 endpoint, properly wrapped around requests. :param method: A string representation of the HTTP method to be used. :param uri: The resource to be requested. :param access_token: Overrides self.access_token. Defaults to None. :param \*\*kwargs: Optional arguments. Same as Requests. """ # see if we can prepend base_url if self.base_url is not None and not absolute_url(uri): uri = urljoin(self.base_url, uri) # see if we can use a stored access_token if access_token is None and self.access_token is None: raise TypeError("access_token must not be None") if access_token is None: access_token = self.access_token kwargs.setdefault("params", {}).update(access_token=access_token) kwargs.setdefault("timeout", DEFAULT_TIMEOUT) response = self.session.request(method, uri, **kwargs) return Response(response)
def request(self, method, uri, **kwargs): """Sends a request to an Ofly endpoint, properly wrapped around requests. :param method: A string representation of the HTTP method to be used. :param url: The resource to be requested. :param header_auth: Authenication via header, defaults to False. :param \*\*kwargs: Optional arguments. Same as Requests. """ params = kwargs.pop("params", None) data = kwargs.pop("data", None) if params is None: params = {} kwargs.setdefault("timeout", DEFAULT_TIMEOUT) if self.base_url is not None and not absolute_url(uri): uri = urljoin(self.base_url, uri) header_auth = kwargs.pop("header_auth", False) if header_auth: params, headers = self._sha1_sign_params(uri, header_auth, **params) response = self.session.request(method, uri + "?" + params, headers=headers, **kwargs) else: params = self._sha1_sign_params(uri, **params) response = self.session.request(method, uri + "?" + params, data=data, **kwargs) return Response(response)
def request(self, method, uri, access_token=None, access_token_secret=None, **kwargs): '''Makes a request using :class:`_construct_session`. :param method: A string representation of the HTTP method to be used. :param uri: The resource to be requested. :param access_token: The access token as returned by :class:`get_access_token`. :param access_token_secret: The access token secret as returned by :class:`get_access_token`. :param header_auth: Authenication via header, defaults to False. :param allow_redirects: Allows a request to redirect, defaults to True. :param \*\*kwargs: Optional arguments. Same as Requests. ''' header_auth = kwargs.pop('header_auth', self.header_auth) kwargs.setdefault('allow_redirects', True) kwargs.setdefault('headers', {}) kwargs.setdefault('params', {}) kwargs.setdefault('timeout', DEFAULT_TIMEOUT) # set the Content-Type if unspecified if method in ('POST', 'PUT'): kwargs['headers'].setdefault('Content-Type', 'application/x-www-form-urlencoded') # prepend a base_url to the uri if we can if self.base_url is not None and not absolute_url(uri): uri = self.base_url + uri # check user supplied tokens tokens = (access_token, access_token_secret) all_tokens_none = all(v is None for v in tokens) if None in tokens and not all_tokens_none: raise TypeError('Either both or neither access_token and ' 'access_token_secret must be supplied') # use default tokens if user supplied tokens are not present if all_tokens_none: access_token = self.access_token access_token_secret = self.access_token_secret session_params = dict(access_token=access_token, access_token_secret=access_token_secret, header_auth=header_auth) auth_session = self._construct_session(**session_params) response = auth_session.request(method, uri, **kwargs) return Response(response)
def _set_url(self, url): if self.service is not None and self.service.base_url is not None and \ not absolute_url(url): return urljoin(self.service.base_url, url) return url
def test_not_absolute_url(self): self.assertFalse(absolute_url('/some/resource'))
def test_absolute_url_https(self): self.assertTrue(absolute_url('https://example.com/'))