desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Returns a list of all joystick event since the last call'
| def read(self):
| if (not self._f):
raise Exception('Joystick device not opened')
self._read_all_events()
return [self.axes, self.buttons]
|
'Returns a dict with device_id as key and device name as value of all
the detected devices (result is cached once one or more device are
found).'
| def devices(self):
| if (len(self._devices) == 0):
syspaths = glob.glob('/sys/class/input/js*')
for path in syspaths:
device_id = int(os.path.basename(path)[2:])
with open((path + '/device/name')) as namefile:
name = namefile.read().strip()
self._js[device_id] = _JS(device_id, name)
self._devices.append({'id': device_id, 'name': name})
return self._devices
|
'Open the joystick device. The device_id is given by available_devices'
| def open(self, device_id):
| self._js[device_id].open()
|
'Open the joystick device'
| def close(self, device_id):
| self._js[device_id].close()
|
'Returns a list of all joystick event since the last call'
| def read(self, device_id):
| return self._js[device_id].read()
|
'Init app with Flask instance.
You can also pass the instance of Flask later::
oauth = OAuth()
oauth.init_app(app)'
| def init_app(self, app):
| self.app = app
app.extensions = getattr(app, 'extensions', {})
app.extensions[self.state_key] = self
|
'Registers a new remote application.
:param name: the name of the remote application
:param register: whether the remote app will be registered
Find more parameters from :class:`OAuthRemoteApp`.'
| def remote_app(self, name, register=True, **kwargs):
| remote = OAuthRemoteApp(self, name, **kwargs)
if register:
assert (name not in self.remote_apps)
self.remote_apps[name] = remote
return remote
|
'The status code of the response.'
| @property
def status(self):
| return self._resp.code
|
'Sends a ``GET`` request. Accepts the same parameters as
:meth:`request`.'
| def get(self, *args, **kwargs):
| kwargs['method'] = 'GET'
return self.request(*args, **kwargs)
|
'Sends a ``POST`` request. Accepts the same parameters as
:meth:`request`.'
| def post(self, *args, **kwargs):
| kwargs['method'] = 'POST'
return self.request(*args, **kwargs)
|
'Sends a ``PUT`` request. Accepts the same parameters as
:meth:`request`.'
| def put(self, *args, **kwargs):
| kwargs['method'] = 'PUT'
return self.request(*args, **kwargs)
|
'Sends a ``DELETE`` request. Accepts the same parameters as
:meth:`request`.'
| def delete(self, *args, **kwargs):
| kwargs['method'] = 'DELETE'
return self.request(*args, **kwargs)
|
'Sends a ``PATCH`` request. Accepts the same parameters as
:meth:`post`.'
| def patch(self, *args, **kwargs):
| kwargs['method'] = 'PATCH'
return self.request(*args, **kwargs)
|
'Sends a request to the remote server with OAuth tokens attached.
:param data: the data to be sent to the server.
:param headers: an optional dictionary of headers.
:param format: the format for the `data`. Can be `urlencoded` for
URL encoded data or `json` for JSON.
:param method: the HTTP request method to use.
:param content_type: an optional content type. If a content type
is provided, the data is passed as it, and
the `format` is ignored.
:param token: an optional token to pass, if it is None, token will
be generated by tokengetter.'
| def request(self, url, data=None, headers=None, format='urlencoded', method='GET', content_type=None, token=None):
| headers = dict((headers or {}))
if (token is None):
token = self.get_request_token()
client = self.make_client(token)
url = self.expand_url(url)
if (method == 'GET'):
assert (format == 'urlencoded')
if data:
url = add_params_to_uri(url, data)
data = None
else:
if (content_type is None):
(data, content_type) = encode_request_data(data, format)
if (content_type is not None):
headers['Content-Type'] = content_type
if self.request_token_url:
(uri, headers, body) = client.sign(url, http_method=method, body=data, headers=headers)
else:
(uri, headers, body) = client.add_token(url, http_method=method, body=data, headers=headers)
if hasattr(self, 'pre_request'):
(uri, headers, body) = self.pre_request(uri, headers, body)
if body:
data = to_bytes(body, self.encoding)
else:
data = None
(resp, content) = self.http_request(uri, headers, data=to_bytes(body, self.encoding), method=method)
return OAuthResponse(resp, content, self.content_type)
|
'Returns a redirect response to the remote authorization URL with
the signed callback given.
:param callback: a redirect url for the callback
:param state: an optional value to embed in the OAuth request.
Use this if you want to pass around application
state (e.g. CSRF tokens).
:param kwargs: add optional key/value pairs to the query string'
| def authorize(self, callback=None, state=None, **kwargs):
| params = (dict(self.request_token_params) or {})
params.update(**kwargs)
if self.request_token_url:
token = self.generate_request_token(callback)[0]
url = ('%s?oauth_token=%s' % (self.expand_url(self.authorize_url), url_quote(token)))
if params:
url += ('&' + url_encode(params))
else:
assert (callback is not None), 'Callback is required OAuth2'
client = self.make_client()
if ('scope' in params):
scope = params.pop('scope')
else:
scope = None
if isinstance(scope, str):
scope = _encode(scope, self.encoding)
if ('state' in params):
if (not state):
state = params.pop('state')
else:
params.pop('state')
if callable(state):
state = state()
session[('%s_oauthredir' % self.name)] = callback
url = client.prepare_request_uri(self.expand_url(self.authorize_url), redirect_uri=callback, scope=scope, state=state, **params)
return redirect(url)
|
'Register a function as token getter.'
| def tokengetter(self, f):
| self._tokengetter = f
return f
|
'Handles an oauth1 authorization response.'
| def handle_oauth1_response(self):
| client = self.make_client()
client.verifier = request.args.get('oauth_verifier')
tup = session.get(('%s_oauthtok' % self.name))
if (not tup):
raise OAuthException('Token not found, maybe you disabled cookie', type='token_not_found')
client.resource_owner_key = tup[0]
client.resource_owner_secret = tup[1]
(uri, headers, data) = client.sign(self.expand_url(self.access_token_url), _encode(self.access_token_method))
headers.update(self._access_token_headers)
(resp, content) = self.http_request(uri, headers, to_bytes(data, self.encoding), method=self.access_token_method)
data = parse_response(resp, content)
if (resp.code not in (200, 201)):
raise OAuthException(('Invalid response from %s' % self.name), type='invalid_response', data=data)
return data
|
'Handles an oauth2 authorization response.'
| def handle_oauth2_response(self):
| client = self.make_client()
remote_args = {'code': request.args.get('code'), 'client_secret': self.consumer_secret, 'redirect_uri': session.get(('%s_oauthredir' % self.name))}
log.debug('Prepare oauth2 remote args %r', remote_args)
remote_args.update(self.access_token_params)
headers = copy(self._access_token_headers)
if (self.access_token_method == 'POST'):
headers.update({'Content-Type': 'application/x-www-form-urlencoded'})
body = client.prepare_request_body(**remote_args)
(resp, content) = self.http_request(self.expand_url(self.access_token_url), headers=headers, data=to_bytes(body, self.encoding), method=self.access_token_method)
elif (self.access_token_method == 'GET'):
qs = client.prepare_request_body(**remote_args)
url = self.expand_url(self.access_token_url)
url += (((('?' in url) and '&') or '?') + qs)
(resp, content) = self.http_request(url, headers=headers, method=self.access_token_method)
else:
raise OAuthException(('Unsupported access_token_method: %s' % self.access_token_method))
data = parse_response(resp, content, content_type=self.content_type)
if (resp.code not in (200, 201)):
raise OAuthException(('Invalid response from %s' % self.name), type='invalid_response', data=data)
return data
|
'Handles a unknown authorization response.'
| def handle_unknown_response(self):
| return None
|
'Handles authorization response smartly.'
| def authorized_response(self):
| if ('oauth_verifier' in request.args):
data = self.handle_oauth1_response()
elif ('code' in request.args):
data = self.handle_oauth2_response()
else:
data = self.handle_unknown_response()
session.pop(('%s_oauthtok' % self.name), None)
session.pop(('%s_oauthredir' % self.name), None)
return data
|
'Handles an OAuth callback.
.. versionchanged:: 0.7
@authorized_handler is deprecated in favor of authorized_response.'
| def authorized_handler(self, f):
| @wraps(f)
def decorated(*args, **kwargs):
log.warn('@authorized_handler is deprecated in favor of authorized_response')
data = self.authorized_response()
return f(*((data,) + args), **kwargs)
return decorated
|
'This callback can be used to initialize an application for the
oauth provider instance.'
| def init_app(self, app):
| self.app = app
app.extensions = getattr(app, 'extensions', {})
app.extensions['oauthlib.provider.oauth2'] = self
|
'The error page URI.
When something turns error, it will redirect to this error page.
You can configure the error page URI with Flask config::
OAUTH2_PROVIDER_ERROR_URI = \'/error\'
You can also define the error page by a named endpoint::
OAUTH2_PROVIDER_ERROR_ENDPOINT = \'oauth.error\''
| @cached_property
def error_uri(self):
| error_uri = self.app.config.get('OAUTH2_PROVIDER_ERROR_URI')
if error_uri:
return error_uri
error_endpoint = self.app.config.get('OAUTH2_PROVIDER_ERROR_ENDPOINT')
if error_endpoint:
return url_for(error_endpoint)
return '/oauth/errors'
|
'All in one endpoints. This property is created automaticly
if you have implemented all the getters and setters.
However, if you are not satisfied with the getter and setter,
you can create a validator with :class:`OAuth2RequestValidator`::
class MyValidator(OAuth2RequestValidator):
def validate_client_id(self, client_id):
# do something
return True
And assign the validator for the provider::
oauth._validator = MyValidator()'
| @cached_property
def server(self):
| expires_in = self.app.config.get('OAUTH2_PROVIDER_TOKEN_EXPIRES_IN')
token_generator = self.app.config.get('OAUTH2_PROVIDER_TOKEN_GENERATOR', None)
if (token_generator and (not callable(token_generator))):
token_generator = import_string(token_generator)
refresh_token_generator = self.app.config.get('OAUTH2_PROVIDER_REFRESH_TOKEN_GENERATOR', None)
if (refresh_token_generator and (not callable(refresh_token_generator))):
refresh_token_generator = import_string(refresh_token_generator)
if hasattr(self, '_validator'):
return Server(self._validator, token_expires_in=expires_in, token_generator=token_generator, refresh_token_generator=refresh_token_generator)
if (hasattr(self, '_clientgetter') and hasattr(self, '_tokengetter') and hasattr(self, '_tokensetter') and hasattr(self, '_grantgetter') and hasattr(self, '_grantsetter')):
usergetter = None
if hasattr(self, '_usergetter'):
usergetter = self._usergetter
validator = OAuth2RequestValidator(clientgetter=self._clientgetter, tokengetter=self._tokengetter, grantgetter=self._grantgetter, usergetter=usergetter, tokensetter=self._tokensetter, grantsetter=self._grantsetter)
self._validator = validator
return Server(validator, token_expires_in=expires_in, token_generator=token_generator, refresh_token_generator=refresh_token_generator)
raise RuntimeError('application not bound to required getters')
|
'Register functions to be invoked before accessing the resource.
The function accepts nothing as parameters, but you can get
information from `Flask.request` object. It is usually useful
for setting limitation on the client request::
@oauth.before_request
def limit_client_request():
client_id = request.values.get(\'client_id\')
if not client_id:
return
client = Client.get(client_id)
if over_limit(client):
return abort(403)
track_request(client)'
| def before_request(self, f):
| self._before_request_funcs.append(f)
return f
|
'Register functions to be invoked after accessing the resource.
The function accepts ``valid`` and ``request`` as parameters,
and it should return a tuple of them::
@oauth.after_request
def valid_after_request(valid, oauth):
if oauth.user in black_list:
return False, oauth
return valid, oauth'
| def after_request(self, f):
| self._after_request_funcs.append(f)
return f
|
'Register a function for responsing with invalid request.
When an invalid request proceeds to :meth:`require_oauth`, we can
handle the request with the registered function. The function
accepts one parameter, which is an oauthlib Request object::
@oauth.invalid_response
def invalid_require_oauth(req):
return jsonify(message=req.error_message), 401
If no function is registered, it will return with ``abort(401)``.'
| def invalid_response(self, f):
| self._invalid_response = f
return f
|
'Register a function as the client getter.
The function accepts one parameter `client_id`, and it returns
a client object with at least these information:
- client_id: A random string
- client_secret: A random string
- is_confidential: A bool represents if it is confidential
- redirect_uris: A list of redirect uris
- default_redirect_uri: One of the redirect uris
- default_scopes: Default scopes of the client
The client may contain more information, which is suggested:
- allowed_grant_types: A list of grant types
- allowed_response_types: A list of response types
- validate_scopes: A function to validate scopes
Implement the client getter::
@oauth.clientgetter
def get_client(client_id):
client = get_client_model(client_id)
# Client is an object
return client'
| def clientgetter(self, f):
| self._clientgetter = f
return f
|
'Register a function as the user getter.
This decorator is only required for **password credential**
authorization::
@oauth.usergetter
def get_user(username, password, client, request,
*args, **kwargs):
# client: current request client
if not client.has_password_credential_permission:
return None
user = User.get_user_by_username(username)
if not user.validate_password(password):
return None
# parameter `request` is an OAuthlib Request object.
# maybe you will need it somewhere
return user'
| def usergetter(self, f):
| self._usergetter = f
return f
|
'Register a function as the token getter.
The function accepts an `access_token` or `refresh_token` parameters,
and it returns a token object with at least these information:
- access_token: A string token
- refresh_token: A string token
- client_id: ID of the client
- scopes: A list of scopes
- expires: A `datetime.datetime` object
- user: The user object
The implementation of tokengetter should accepts two parameters,
one is access_token the other is refresh_token::
@oauth.tokengetter
def bearer_token(access_token=None, refresh_token=None):
if access_token:
return get_token(access_token=access_token)
if refresh_token:
return get_token(refresh_token=refresh_token)
return None'
| def tokengetter(self, f):
| self._tokengetter = f
return f
|
'Register a function to save the bearer token.
The setter accepts two parameters at least, one is token,
the other is request::
@oauth.tokensetter
def set_token(token, request, *args, **kwargs):
save_token(token, request.client, request.user)
The parameter token is a dict, that looks like::
u\'access_token\': u\'6JwgO77PApxsFCU8Quz0pnL9s23016\',
u\'token_type\': u\'Bearer\',
u\'expires_in\': 3600,
u\'scope\': u\'email address\'
The request is an object, that contains an user object and a
client object.'
| def tokensetter(self, f):
| self._tokensetter = f
return f
|
'Register a function as the grant getter.
The function accepts `client_id`, `code` and more::
@oauth.grantgetter
def grant(client_id, code):
return get_grant(client_id, code)
It returns a grant object with at least these information:
- delete: A function to delete itself'
| def grantgetter(self, f):
| self._grantgetter = f
return f
|
'Register a function to save the grant code.
The function accepts `client_id`, `code`, `request` and more::
@oauth.grantsetter
def set_grant(client_id, code, request, *args, **kwargs):
save_grant(client_id, code, request.user, request.scopes)'
| def grantsetter(self, f):
| self._grantsetter = f
return f
|
'Authorization handler decorator.
This decorator will sort the parameters and headers out, and
pre validate everything::
@app.route(\'/oauth/authorize\', methods=[\'GET\', \'POST\'])
@oauth.authorize_handler
def authorize(*args, **kwargs):
if request.method == \'GET\':
# render a page for user to confirm the authorization
return render_template(\'oauthorize.html\')
confirm = request.form.get(\'confirm\', \'no\')
return confirm == \'yes\''
| def authorize_handler(self, f):
| @wraps(f)
def decorated(*args, **kwargs):
server = self.server
(uri, http_method, body, headers) = extract_params()
if (request.method in ('GET', 'HEAD')):
redirect_uri = request.args.get('redirect_uri', self.error_uri)
log.debug('Found redirect_uri %s.', redirect_uri)
try:
ret = server.validate_authorization_request(uri, http_method, body, headers)
(scopes, credentials) = ret
kwargs['scopes'] = scopes
kwargs.update(credentials)
except oauth2.FatalClientError as e:
log.debug('Fatal client error %r', e, exc_info=True)
return redirect(e.in_uri(self.error_uri))
except oauth2.OAuth2Error as e:
log.debug('OAuth2Error: %r', e, exc_info=True)
return redirect(e.in_uri(redirect_uri))
except Exception as e:
log.exception(e)
return redirect(add_params_to_uri(self.error_uri, {'error': str(e)}))
else:
redirect_uri = request.values.get('redirect_uri', self.error_uri)
try:
rv = f(*args, **kwargs)
except oauth2.FatalClientError as e:
log.debug('Fatal client error %r', e, exc_info=True)
return redirect(e.in_uri(self.error_uri))
except oauth2.OAuth2Error as e:
log.debug('OAuth2Error: %r', e, exc_info=True)
return redirect(e.in_uri(redirect_uri))
if (not isinstance(rv, bool)):
return rv
if (not rv):
e = oauth2.AccessDeniedError()
return redirect(e.in_uri(redirect_uri))
return self.confirm_authorization_request()
return decorated
|
'When consumer confirm the authorization.'
| def confirm_authorization_request(self):
| server = self.server
scope = (request.values.get('scope') or '')
scopes = scope.split()
credentials = dict(client_id=request.values.get('client_id'), redirect_uri=request.values.get('redirect_uri', None), response_type=request.values.get('response_type', None), state=request.values.get('state', None))
log.debug('Fetched credentials from request %r.', credentials)
redirect_uri = credentials.get('redirect_uri')
log.debug('Found redirect_uri %s.', redirect_uri)
(uri, http_method, body, headers) = extract_params()
try:
ret = server.create_authorization_response(uri, http_method, body, headers, scopes, credentials)
log.debug('Authorization successful.')
return create_response(*ret)
except oauth2.FatalClientError as e:
log.debug('Fatal client error %r', e, exc_info=True)
return redirect(e.in_uri(self.error_uri))
except oauth2.OAuth2Error as e:
log.debug('OAuth2Error: %r', e, exc_info=True)
return redirect(e.in_uri((redirect_uri or self.error_uri)))
except Exception as e:
log.exception(e)
return redirect(add_params_to_uri(self.error_uri, {'error': str(e)}))
|
'Verify current request, get the oauth data.
If you can\'t use the ``require_oauth`` decorator, you can fetch
the data in your request body::
def your_handler():
valid, req = oauth.verify_request([\'email\'])
if valid:
return jsonify(user=req.user)
return jsonify(status=\'error\')'
| def verify_request(self, scopes):
| (uri, http_method, body, headers) = extract_params()
return self.server.verify_request(uri, http_method, body, headers, scopes)
|
'Access/refresh token handler decorator.
The decorated function should return an dictionary or None as
the extra credentials for creating the token response.
You can control the access method with standard flask route mechanism.
If you only allow the `POST` method::
@app.route(\'/oauth/token\', methods=[\'POST\'])
@oauth.token_handler
def access_token():
return None'
| def token_handler(self, f):
| @wraps(f)
def decorated(*args, **kwargs):
server = self.server
(uri, http_method, body, headers) = extract_params()
credentials = (f(*args, **kwargs) or {})
log.debug('Fetched extra credentials, %r.', credentials)
ret = server.create_token_response(uri, http_method, body, headers, credentials)
return create_response(*ret)
return decorated
|
'Access/refresh token revoke decorator.
Any return value by the decorated function will get discarded as
defined in [`RFC7009`_].
You can control the access method with the standard flask routing
mechanism, as per [`RFC7009`_] it is recommended to only allow
the `POST` method::
@app.route(\'/oauth/revoke\', methods=[\'POST\'])
@oauth.revoke_handler
def revoke_token():
pass
.. _`RFC7009`: http://tools.ietf.org/html/rfc7009'
| def revoke_handler(self, f):
| @wraps(f)
def decorated(*args, **kwargs):
server = self.server
token = request.values.get('token')
request.token_type_hint = request.values.get('token_type_hint')
if token:
request.token = token
(uri, http_method, body, headers) = extract_params()
ret = server.create_revocation_response(uri, headers=headers, body=body, http_method=http_method)
return create_response(*ret)
return decorated
|
'Protect resource with specified scopes.'
| def require_oauth(self, *scopes):
| def wrapper(f):
@wraps(f)
def decorated(*args, **kwargs):
for func in self._before_request_funcs:
func()
if (hasattr(request, 'oauth') and request.oauth):
return f(*args, **kwargs)
(valid, req) = self.verify_request(scopes)
for func in self._after_request_funcs:
(valid, req) = func(valid, req)
if (not valid):
if self._invalid_response:
return self._invalid_response(req)
return abort(401)
request.oauth = req
return f(*args, **kwargs)
return decorated
return wrapper
|
'Return client credentials based on the current request.
According to the rfc6749, client MAY use the HTTP Basic authentication
scheme as defined in [RFC2617] to authenticate with the authorization
server. The client identifier is encoded using the
"application/x-www-form-urlencoded" encoding algorithm per Appendix B,
and the encoded value is used as the username; the client password is
encoded using the same algorithm and used as the password. The
authorization server MUST support the HTTP Basic authentication scheme
for authenticating clients that were issued a client password.
See `Section 2.3.1`_.
.. _`Section 2.3.1`: https://tools.ietf.org/html/rfc6749#section-2.3.1'
| def _get_client_creds_from_request(self, request):
| if (request.client_id is not None):
return (request.client_id, request.client_secret)
auth = request.headers.get('Authorization')
if isinstance(auth, dict):
return (auth['username'], auth['password'])
return (None, None)
|
'Determine if client authentication is required for current request.
According to the rfc6749, client authentication is required in the
following cases:
Resource Owner Password Credentials Grant: see `Section 4.3.2`_.
Authorization Code Grant: see `Section 4.1.3`_.
Refresh Token Grant: see `Section 6`_.
.. _`Section 4.3.2`: http://tools.ietf.org/html/rfc6749#section-4.3.2
.. _`Section 4.1.3`: http://tools.ietf.org/html/rfc6749#section-4.1.3
.. _`Section 6`: http://tools.ietf.org/html/rfc6749#section-6'
| def client_authentication_required(self, request, *args, **kwargs):
| def is_confidential(client):
if hasattr(client, 'is_confidential'):
return client.is_confidential
client_type = getattr(client, 'client_type', None)
if client_type:
return (client_type == 'confidential')
return True
grant_types = ('password', 'authorization_code', 'refresh_token')
(client_id, _) = self._get_client_creds_from_request(request)
if (client_id and (request.grant_type in grant_types)):
client = self._clientgetter(client_id)
if client:
return is_confidential(client)
return False
|
'Authenticate itself in other means.
Other means means is described in `Section 3.2.1`_.
.. _`Section 3.2.1`: http://tools.ietf.org/html/rfc6749#section-3.2.1'
| def authenticate_client(self, request, *args, **kwargs):
| (client_id, client_secret) = self._get_client_creds_from_request(request)
log.debug('Authenticate client %r', client_id)
client = self._clientgetter(client_id)
if (not client):
log.debug('Authenticate client failed, client not found.')
return False
request.client = client
if (hasattr(client, 'client_secret') and (client.client_secret != client_secret)):
log.debug('Authenticate client failed, secret not match.')
return False
log.debug('Authenticate client success.')
return True
|
'Authenticate a non-confidential client.
:param client_id: Client ID of the non-confidential client
:param request: The Request object passed by oauthlib'
| def authenticate_client_id(self, client_id, request, *args, **kwargs):
| if (client_id is None):
(client_id, _) = self._get_client_creds_from_request(request)
log.debug('Authenticate client %r.', client_id)
client = (request.client or self._clientgetter(client_id))
if (not client):
log.debug('Authenticate failed, client not found.')
return False
request.client = client
return True
|
'Ensure client is authorized to redirect to the redirect_uri.
This method is used in the authorization code grant flow. It will
compare redirect_uri and the one in grant token strictly, you can
add a `validate_redirect_uri` function on grant for a customized
validation.'
| def confirm_redirect_uri(self, client_id, code, redirect_uri, client, *args, **kwargs):
| client = (client or self._clientgetter(client_id))
log.debug('Confirm redirect uri for client %r and code %r.', client.client_id, code)
grant = self._grantgetter(client_id=client.client_id, code=code)
if (not grant):
log.debug('Grant not found.')
return False
if hasattr(grant, 'validate_redirect_uri'):
return grant.validate_redirect_uri(redirect_uri)
log.debug('Compare redirect uri for grant %r and %r.', grant.redirect_uri, redirect_uri)
testing = ('OAUTHLIB_INSECURE_TRANSPORT' in os.environ)
if (testing and (redirect_uri is None)):
return True
return (grant.redirect_uri == redirect_uri)
|
'Get the list of scopes associated with the refresh token.
This method is used in the refresh token grant flow. We return
the scope of the token to be refreshed so it can be applied to the
new access token.'
| def get_original_scopes(self, refresh_token, request, *args, **kwargs):
| log.debug('Obtaining scope of refreshed token.')
tok = self._tokengetter(refresh_token=refresh_token)
return tok.scopes
|
'Ensures the requested scope matches the scope originally granted
by the resource owner. If the scope is omitted it is treated as equal
to the scope originally granted by the resource owner.
DEPRECATION NOTE: This method will cease to be used in oauthlib>0.4.2,
future versions of ``oauthlib`` use the validator method
``get_original_scopes`` to determine the scope of the refreshed token.'
| def confirm_scopes(self, refresh_token, scopes, request, *args, **kwargs):
| if (not scopes):
log.debug('Scope omitted for refresh token %r', refresh_token)
return True
log.debug('Confirm scopes %r for refresh token %r', scopes, refresh_token)
tok = self._tokengetter(refresh_token=refresh_token)
return (set(tok.scopes) == set(scopes))
|
'Default redirect_uri for the given client.'
| def get_default_redirect_uri(self, client_id, request, *args, **kwargs):
| request.client = (request.client or self._clientgetter(client_id))
redirect_uri = request.client.default_redirect_uri
log.debug('Found default redirect uri %r', redirect_uri)
return redirect_uri
|
'Default scopes for the given client.'
| def get_default_scopes(self, client_id, request, *args, **kwargs):
| request.client = (request.client or self._clientgetter(client_id))
scopes = request.client.default_scopes
log.debug('Found default scopes %r', scopes)
return scopes
|
'Invalidate an authorization code after use.
We keep the temporary code in a grant, which has a `delete`
function to destroy itself.'
| def invalidate_authorization_code(self, client_id, code, request, *args, **kwargs):
| log.debug('Destroy grant token for client %r, %r', client_id, code)
grant = self._grantgetter(client_id=client_id, code=code)
if grant:
grant.delete()
|
'Persist the authorization code.'
| def save_authorization_code(self, client_id, code, request, *args, **kwargs):
| log.debug('Persist authorization code %r for client %r', code, client_id)
request.client = (request.client or self._clientgetter(client_id))
self._grantsetter(client_id, code, request, *args, **kwargs)
return request.client.default_redirect_uri
|
'Persist the Bearer token.'
| def save_bearer_token(self, token, request, *args, **kwargs):
| log.debug('Save bearer token %r', token)
self._tokensetter(token, request, *args, **kwargs)
return request.client.default_redirect_uri
|
'Validate access token.
:param token: A string of random characters
:param scopes: A list of scopes
:param request: The Request object passed by oauthlib
The validation validates:
1) if the token is available
2) if the token has expired
3) if the scopes are available'
| def validate_bearer_token(self, token, scopes, request):
| log.debug('Validate bearer token %r', token)
tok = self._tokengetter(access_token=token)
if (not tok):
msg = 'Bearer token not found.'
request.error_message = msg
log.debug(msg)
return False
if ((tok.expires is not None) and (datetime.datetime.utcnow() > tok.expires)):
msg = 'Bearer token is expired.'
request.error_message = msg
log.debug(msg)
return False
if (scopes and (not (set(tok.scopes) & set(scopes)))):
msg = 'Bearer token scope not valid.'
request.error_message = msg
log.debug(msg)
return False
request.access_token = tok
request.user = tok.user
request.scopes = scopes
if hasattr(tok, 'client'):
request.client = tok.client
elif hasattr(tok, 'client_id'):
request.client = self._clientgetter(tok.client_id)
return True
|
'Ensure client_id belong to a valid and active client.'
| def validate_client_id(self, client_id, request, *args, **kwargs):
| log.debug('Validate client %r', client_id)
client = (request.client or self._clientgetter(client_id))
if client:
request.client = client
return True
return False
|
'Ensure the grant code is valid.'
| def validate_code(self, client_id, code, client, request, *args, **kwargs):
| client = (client or self._clientgetter(client_id))
log.debug('Validate code for client %r and code %r', client.client_id, code)
grant = self._grantgetter(client_id=client.client_id, code=code)
if (not grant):
log.debug('Grant not found.')
return False
if (hasattr(grant, 'expires') and (datetime.datetime.utcnow() > grant.expires)):
log.debug('Grant is expired.')
return False
request.state = kwargs.get('state')
request.user = grant.user
request.scopes = grant.scopes
return True
|
'Ensure the client is authorized to use the grant type requested.
It will allow any of the four grant types (`authorization_code`,
`password`, `client_credentials`, `refresh_token`) by default.
Implemented `allowed_grant_types` for client object to authorize
the request.
It is suggested that `allowed_grant_types` should contain at least
`authorization_code` and `refresh_token`.'
| def validate_grant_type(self, client_id, grant_type, client, request, *args, **kwargs):
| if ((self._usergetter is None) and (grant_type == 'password')):
log.debug('Password credential authorization is disabled.')
return False
default_grant_types = ('authorization_code', 'password', 'client_credentials', 'refresh_token')
if hasattr(client, 'allowed_grant_types'):
if (grant_type not in client.allowed_grant_types):
return False
elif (grant_type not in default_grant_types):
return False
if (grant_type == 'client_credentials'):
if (not hasattr(client, 'user')):
log.debug('Client should have a user property')
return False
request.user = client.user
return True
|
'Ensure client is authorized to redirect to the redirect_uri.
This method is used in the authorization code grant flow and also
in implicit grant flow. It will detect if redirect_uri in client\'s
redirect_uris strictly, you can add a `validate_redirect_uri`
function on grant for a customized validation.'
| def validate_redirect_uri(self, client_id, redirect_uri, request, *args, **kwargs):
| request.client = (request.client or self._clientgetter(client_id))
client = request.client
if hasattr(client, 'validate_redirect_uri'):
return client.validate_redirect_uri(redirect_uri)
return (redirect_uri in client.redirect_uris)
|
'Ensure the token is valid and belongs to the client
This method is used by the authorization code grant indirectly by
issuing refresh tokens, resource owner password credentials grant
(also indirectly) and the refresh token grant.'
| def validate_refresh_token(self, refresh_token, client, request, *args, **kwargs):
| token = self._tokengetter(refresh_token=refresh_token)
if (token and (token.client_id == client.client_id)):
request.client_id = token.client_id
request.user = token.user
return True
return False
|
'Ensure client is authorized to use the response type requested.
It will allow any of the two (`code`, `token`) response types by
default. Implemented `allowed_response_types` for client object
to authorize the request.'
| def validate_response_type(self, client_id, response_type, client, request, *args, **kwargs):
| if (response_type not in ('code', 'token')):
return False
if hasattr(client, 'allowed_response_types'):
return (response_type in client.allowed_response_types)
return True
|
'Ensure the client is authorized access to requested scopes.'
| def validate_scopes(self, client_id, scopes, client, request, *args, **kwargs):
| if hasattr(client, 'validate_scopes'):
return client.validate_scopes(scopes)
return set(client.default_scopes).issuperset(set(scopes))
|
'Ensure the username and password is valid.
Attach user object on request for later using.'
| def validate_user(self, username, password, client, request, *args, **kwargs):
| log.debug('Validating username %r and its password', username)
if (self._usergetter is not None):
user = self._usergetter(username, password, client, request, *args, **kwargs)
if user:
request.user = user
return True
return False
log.debug('Password credential authorization is disabled.')
return False
|
'Revoke an access or refresh token.'
| def revoke_token(self, token, token_type_hint, request, *args, **kwargs):
| if token_type_hint:
tok = self._tokengetter(**{token_type_hint: token})
else:
tok = self._tokengetter(access_token=token)
if (not tok):
tok = self._tokengetter(refresh_token=token)
if tok:
request.client_id = tok.client_id
request.user = tok.user
tok.delete()
return True
msg = 'Invalid token supplied.'
log.debug(msg)
request.error_message = msg
return False
|
'This callback can be used to initialize an application for the
oauth provider instance.'
| def init_app(self, app):
| self.app = app
app.extensions = getattr(app, 'extensions', {})
app.extensions['oauthlib.provider.oauth1'] = self
|
'The error page URI.
When something turns error, it will redirect to this error page.
You can configure the error page URI with Flask config::
OAUTH1_PROVIDER_ERROR_URI = \'/error\'
You can also define the error page by a named endpoint::
OAUTH1_PROVIDER_ERROR_ENDPOINT = \'oauth.error\''
| @cached_property
def error_uri(self):
| error_uri = self.app.config.get('OAUTH1_PROVIDER_ERROR_URI')
if error_uri:
return error_uri
error_endpoint = self.app.config.get('OAUTH1_PROVIDER_ERROR_ENDPOINT')
if error_endpoint:
return url_for(error_endpoint)
return '/oauth/errors'
|
'All in one endpoints. This property is created automaticly
if you have implemented all the getters and setters.'
| @cached_property
def server(self):
| if hasattr(self, '_validator'):
return Server(self._validator)
if (hasattr(self, '_clientgetter') and hasattr(self, '_tokengetter') and hasattr(self, '_tokensetter') and hasattr(self, '_noncegetter') and hasattr(self, '_noncesetter') and hasattr(self, '_grantgetter') and hasattr(self, '_grantsetter') and hasattr(self, '_verifiergetter') and hasattr(self, '_verifiersetter')):
validator = OAuth1RequestValidator(clientgetter=self._clientgetter, tokengetter=self._tokengetter, tokensetter=self._tokensetter, grantgetter=self._grantgetter, grantsetter=self._grantsetter, noncegetter=self._noncegetter, noncesetter=self._noncesetter, verifiergetter=self._verifiergetter, verifiersetter=self._verifiersetter, config=self.app.config)
self._validator = validator
server = Server(validator)
if self.app.testing:
server._check_signature = (lambda *args, **kwargs: True)
return server
raise RuntimeError('application not bound to required getters and setters')
|
'Register functions to be invoked before accessing the resource.
The function accepts nothing as parameters, but you can get
information from `Flask.request` object. It is usually useful
for setting limitation on the client request::
@oauth.before_request
def limit_client_request():
client_key = request.values.get(\'client_key\')
if not client_key:
return
client = Client.get(client_key)
if over_limit(client):
return abort(403)
track_request(client)'
| def before_request(self, f):
| self._before_request_funcs.append(f)
return f
|
'Register functions to be invoked after accessing the resource.
The function accepts ``valid`` and ``request`` as parameters,
and it should return a tuple of them::
@oauth.after_request
def valid_after_request(valid, oauth):
if oauth.user in black_list:
return False, oauth
return valid, oauth'
| def after_request(self, f):
| self._after_request_funcs.append(f)
return f
|
'Register a function as the client getter.
The function accepts one parameter `client_key`, and it returns
a client object with at least these information:
- client_key: A random string
- client_secret: A random string
- redirect_uris: A list of redirect uris
- default_realms: Default scopes of the client
The client may contain more information, which is suggested:
- default_redirect_uri: One of the redirect uris
Implement the client getter::
@oauth.clientgetter
def get_client(client_key):
client = get_client_model(client_key)
# Client is an object
return client'
| def clientgetter(self, f):
| self._clientgetter = f
return f
|
'Register a function as the access token getter.
The function accepts `client_key` and `token` parameters, and it
returns an access token object contains:
- client: Client associated with this token
- user: User associated with this token
- token: Access token
- secret: Access token secret
- realms: Realms with this access token
Implement the token getter::
@oauth.tokengetter
def get_access_token(client_key, token):
return AccessToken.get(client_key=client_key, token=token)'
| def tokengetter(self, f):
| self._tokengetter = f
return f
|
'Register a function as the access token setter.
The setter accepts two parameters at least, one is token,
the other is request::
@oauth.tokensetter
def save_access_token(token, request):
access_token = AccessToken(
client=request.client,
user=request.user,
token=token[\'oauth_token\'],
secret=token[\'oauth_token_secret\'],
realms=token[\'oauth_authorized_realms\'].split(\' \'),
return access_token.save()
The parameter token is a dict, that looks like::
u\'oauth_token\': u\'arandomstringoftoken\',
u\'oauth_token_secret\': u\'arandomstringofsecret\',
u\'oauth_authorized_realms\': u\'email address\'
The `request` object would provide these information (at least)::
- client: Client object associated with this token
- user: User object associated with this token
- request_token: Requst token for exchanging this access token'
| def tokensetter(self, f):
| self._tokensetter = f
return f
|
'Register a function as the request token getter.
The function accepts a `token` parameter, and it returns an
request token object contains:
- client: Client associated with this token
- token: Access token
- secret: Access token secret
- realms: Realms with this access token
- redirect_uri: A URI for redirecting
Implement the token getter::
@oauth.tokengetter
def get_request_token(token):
return RequestToken.get(token=token)'
| def grantgetter(self, f):
| self._grantgetter = f
return f
|
'Register a function as the request token setter.
The setter accepts a token and request parameters::
@oauth.grantsetter
def save_request_token(token, request):
data = RequestToken(
token=token[\'oauth_token\'],
secret=token[\'oauth_token_secret\'],
client=request.client,
redirect_uri=oauth.redirect_uri,
realms=request.realms,
return data.save()'
| def grantsetter(self, f):
| self._grantsetter = f
return f
|
'Register a function as the nonce and timestamp getter.
The function accepts parameters:
- client_key: The client/consure key
- timestamp: The ``oauth_timestamp`` parameter
- nonce: The ``oauth_nonce`` parameter
- request_token: Request token string, if any
- access_token: Access token string, if any
A nonce and timestamp make each request unique. The implementation::
@oauth.noncegetter
def get_nonce(client_key, timestamp, nonce, request_token,
access_token):
return Nonce.get("...")'
| def noncegetter(self, f):
| self._noncegetter = f
return f
|
'Register a function as the nonce and timestamp setter.
The parameters are the same with :meth:`noncegetter`::
@oauth.noncegetter
def save_nonce(client_key, timestamp, nonce, request_token,
access_token):
data = Nonce("...")
return data.save()
The timestamp will be expired in 60s, it would be a better design
if you put timestamp and nonce object in a cache.'
| def noncesetter(self, f):
| self._noncesetter = f
return f
|
'Register a function as the verifier getter.
The return verifier object should at least contain a user object
which is the current user.
The implemented code looks like::
@oauth.verifiergetter
def load_verifier(verifier, token):
data = Verifier.get(verifier)
if data.request_token == token:
# check verifier for safety
return data
return data'
| def verifiergetter(self, f):
| self._verifiergetter = f
return f
|
'Register a function as the verifier setter.
A verifier is better together with request token, but it is not
required. A verifier is used together with request token for
exchanging access token, it has an expire time, in this case, it
would be a better design if you put them in a cache.
The implemented code looks like::
@oauth.verifiersetter
def save_verifier(verifier, token, *args, **kwargs):
data = Verifier(
verifier=verifier[\'oauth_verifier\'],
request_token=token,
user=get_current_user()
return data.save()'
| def verifiersetter(self, f):
| self._verifiersetter = f
return f
|
'Authorization handler decorator.
This decorator will sort the parameters and headers out, and
pre validate everything::
@app.route(\'/oauth/authorize\', methods=[\'GET\', \'POST\'])
@oauth.authorize_handler
def authorize(*args, **kwargs):
if request.method == \'GET\':
# render a page for user to confirm the authorization
return render_template(\'oauthorize.html\')
confirm = request.form.get(\'confirm\', \'no\')
return confirm == \'yes\''
| def authorize_handler(self, f):
| @wraps(f)
def decorated(*args, **kwargs):
if (request.method == 'POST'):
if (not f(*args, **kwargs)):
uri = add_params_to_uri(self.error_uri, [('error', 'denied')])
return redirect(uri)
return self.confirm_authorization_request()
server = self.server
(uri, http_method, body, headers) = extract_params()
try:
(realms, credentials) = server.get_realms_and_credentials(uri, http_method=http_method, body=body, headers=headers)
kwargs['realms'] = realms
kwargs.update(credentials)
return f(*args, **kwargs)
except errors.OAuth1Error as e:
return redirect(e.in_uri(self.error_uri))
except errors.InvalidClientError as e:
return redirect(e.in_uri(self.error_uri))
return decorated
|
'When consumer confirm the authrozation.'
| def confirm_authorization_request(self):
| server = self.server
(uri, http_method, body, headers) = extract_params()
try:
(realms, credentials) = server.get_realms_and_credentials(uri, http_method=http_method, body=body, headers=headers)
ret = server.create_authorization_response(uri, http_method, body, headers, realms, credentials)
log.debug('Authorization successful.')
return create_response(*ret)
except errors.OAuth1Error as e:
return redirect(e.in_uri(self.error_uri))
except errors.InvalidClientError as e:
return redirect(e.in_uri(self.error_uri))
|
'Request token handler decorator.
The decorated function should return an dictionary or None as
the extra credentials for creating the token response.
If you don\'t need to add any extra credentials, it could be as
simple as::
@app.route(\'/oauth/request_token\')
@oauth.request_token_handler
def request_token():
return {}'
| def request_token_handler(self, f):
| @wraps(f)
def decorated(*args, **kwargs):
server = self.server
(uri, http_method, body, headers) = extract_params()
credentials = f(*args, **kwargs)
try:
ret = server.create_request_token_response(uri, http_method, body, headers, credentials)
return create_response(*ret)
except errors.OAuth1Error as e:
return _error_response(e)
return decorated
|
'Access token handler decorator.
The decorated function should return an dictionary or None as
the extra credentials for creating the token response.
If you don\'t need to add any extra credentials, it could be as
simple as::
@app.route(\'/oauth/access_token\')
@oauth.access_token_handler
def access_token():
return {}'
| def access_token_handler(self, f):
| @wraps(f)
def decorated(*args, **kwargs):
server = self.server
(uri, http_method, body, headers) = extract_params()
credentials = f(*args, **kwargs)
try:
ret = server.create_access_token_response(uri, http_method, body, headers, credentials)
return create_response(*ret)
except errors.OAuth1Error as e:
return _error_response(e)
return decorated
|
'Protect resource with specified scopes.'
| def require_oauth(self, *realms, **kwargs):
| def wrapper(f):
@wraps(f)
def decorated(*args, **kwargs):
for func in self._before_request_funcs:
func()
if (hasattr(request, 'oauth') and request.oauth):
return f(*args, **kwargs)
server = self.server
(uri, http_method, body, headers) = extract_params()
try:
(valid, req) = server.validate_protected_resource_request(uri, http_method, body, headers, realms)
except Exception as e:
log.warn('Exception: %r', e)
e.urlencoded = urlencode([('error', 'unknown')])
e.status_code = 400
return _error_response(e)
for func in self._after_request_funcs:
(valid, req) = func(valid, req)
if (not valid):
return abort(401)
req.user = req.access_token.user
request.oauth = req
return f(*args, **kwargs)
return decorated
return wrapper
|
'Allowed signature methods.
Default value: SIGNATURE_HMAC and SIGNATURE_RSA.
You can customize with Flask Config:
- OAUTH1_PROVIDER_SIGNATURE_METHODS'
| @property
def allowed_signature_methods(self):
| return self._config.get('OAUTH1_PROVIDER_SIGNATURE_METHODS', SIGNATURE_METHODS)
|
'Enforce SSL request.
Default is True. You can customize with:
- OAUTH1_PROVIDER_ENFORCE_SSL'
| @property
def enforce_ssl(self):
| return self._config.get('OAUTH1_PROVIDER_ENFORCE_SSL', True)
|
'Get client secret.
The client object must has ``client_secret`` attribute.'
| def get_client_secret(self, client_key, request):
| log.debug('Get client secret of %r', client_key)
if (not request.client):
request.client = self._clientgetter(client_key=client_key)
if request.client:
return request.client.client_secret
return None
|
'Get request token secret.
The request token object should a ``secret`` attribute.'
| def get_request_token_secret(self, client_key, token, request):
| log.debug('Get request token secret of %r for %r', token, client_key)
tok = (request.request_token or self._grantgetter(token=token))
if (tok and (tok.client_key == client_key)):
request.request_token = tok
return tok.secret
return None
|
'Get access token secret.
The access token object should a ``secret`` attribute.'
| def get_access_token_secret(self, client_key, token, request):
| log.debug('Get access token secret of %r for %r', token, client_key)
tok = (request.access_token or self._tokengetter(client_key=client_key, token=token))
if tok:
request.access_token = tok
return tok.secret
return None
|
'Default realms of the client.'
| def get_default_realms(self, client_key, request):
| log.debug('Get realms for %r', client_key)
if (not request.client):
request.client = self._clientgetter(client_key=client_key)
client = request.client
if hasattr(client, 'default_realms'):
return client.default_realms
return []
|
'Realms for this request token.'
| def get_realms(self, token, request):
| log.debug('Get realms of %r', token)
tok = (request.request_token or self._grantgetter(token=token))
if (not tok):
return []
request.request_token = tok
if hasattr(tok, 'realms'):
return (tok.realms or [])
return []
|
'Redirect uri for this request token.'
| def get_redirect_uri(self, token, request):
| log.debug('Get redirect uri of %r', token)
tok = (request.request_token or self._grantgetter(token=token))
return tok.redirect_uri
|
'Retrieves a previously stored client provided RSA key.'
| def get_rsa_key(self, client_key, request):
| if (not request.client):
request.client = self._clientgetter(client_key=client_key)
if hasattr(request.client, 'rsa_key'):
return request.client.rsa_key
return None
|
'Validates that supplied client key.'
| def validate_client_key(self, client_key, request):
| log.debug('Validate client key for %r', client_key)
if (not request.client):
request.client = self._clientgetter(client_key=client_key)
if request.client:
return True
return False
|
'Validates request token is available for client.'
| def validate_request_token(self, client_key, token, request):
| log.debug('Validate request token %r for %r', token, client_key)
tok = (request.request_token or self._grantgetter(token=token))
if (tok and (tok.client_key == client_key)):
request.request_token = tok
return True
return False
|
'Validates access token is available for client.'
| def validate_access_token(self, client_key, token, request):
| log.debug('Validate access token %r for %r', token, client_key)
tok = (request.access_token or self._tokengetter(client_key=client_key, token=token))
if tok:
request.access_token = tok
return True
return False
|
'Validate the timestamp and nonce is used or not.'
| def validate_timestamp_and_nonce(self, client_key, timestamp, nonce, request, request_token=None, access_token=None):
| log.debug('Validate timestamp and nonce %r', client_key)
nonce_exists = self._noncegetter(client_key=client_key, timestamp=timestamp, nonce=nonce, request_token=request_token, access_token=access_token)
if nonce_exists:
return False
self._noncesetter(client_key=client_key, timestamp=timestamp, nonce=nonce, request_token=request_token, access_token=access_token)
return True
|
'Validate if the redirect_uri is allowed by the client.'
| def validate_redirect_uri(self, client_key, redirect_uri, request):
| log.debug('Validate redirect_uri %r for %r', redirect_uri, client_key)
if (not request.client):
request.client = self._clientgetter(client_key=client_key)
if (not request.client):
return False
if ((not request.client.redirect_uris) and (redirect_uri is None)):
return True
request.redirect_uri = redirect_uri
return (redirect_uri in request.client.redirect_uris)
|
'Check if the token has permission on those realms.'
| def validate_realms(self, client_key, token, request, uri=None, realms=None):
| log.debug('Validate realms %r for %r', realms, client_key)
if request.access_token:
tok = request.access_token
else:
tok = self._tokengetter(client_key=client_key, token=token)
request.access_token = tok
if (not tok):
return False
return set(tok.realms).issuperset(set(realms))
|
'Validate verifier exists.'
| def validate_verifier(self, client_key, token, verifier, request):
| log.debug('Validate verifier %r for %r', verifier, client_key)
data = self._verifiergetter(verifier=verifier, token=token)
if (not data):
return False
if (not hasattr(data, 'user')):
log.debug('Verifier should has user attribute')
return False
request.user = data.user
if hasattr(data, 'client_key'):
return (data.client_key == client_key)
return True
|
'Verify if the request token is existed.'
| def verify_request_token(self, token, request):
| log.debug('Verify request token %r', token)
tok = (request.request_token or self._grantgetter(token=token))
if tok:
request.request_token = tok
return True
return False
|
'Verify if the realms match the requested realms.'
| def verify_realms(self, token, realms, request):
| log.debug('Verify realms %r', realms)
tok = (request.request_token or self._grantgetter(token=token))
if (not tok):
return False
request.request_token = tok
if (not hasattr(tok, 'realms')):
return True
return (set(tok.realms) == set(realms))
|
'Save access token to database.
A tokensetter is required, which accepts a token and request
parameters::
def tokensetter(token, request):
access_token = Token(
client=request.client,
user=request.user,
token=token[\'oauth_token\'],
secret=token[\'oauth_token_secret\'],
realms=token[\'oauth_authorized_realms\'],
return access_token.save()'
| def save_access_token(self, token, request):
| log.debug('Save access token %r', token)
self._tokensetter(token, request)
|
'Save request token to database.
A grantsetter is required, which accepts a token and request
parameters::
def grantsetter(token, request):
grant = Grant(
token=token[\'oauth_token\'],
secret=token[\'oauth_token_secret\'],
client=request.client,
redirect_uri=oauth.redirect_uri,
realms=request.realms,
return grant.save()'
| def save_request_token(self, token, request):
| log.debug('Save request token %r', token)
self._grantsetter(token, request)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.