_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q269600 | OptionsProviderMixIn.load_defaults | test | def load_defaults(self):
"""initialize the provider using default values"""
for opt, optdict in self.options:
action = optdict.get("action")
if action != "callback":
# callback action have no default
if optdict is None:
optdict ... | python | {
"resource": ""
} |
q269601 | OptionsProviderMixIn.option_attrname | test | def option_attrname(self, opt, optdict=None):
"""get the config attribute corresponding to opt"""
if optdict is None:
optdict = self.get_option_def(opt)
return optdict.get("dest", opt.replace("-", "_")) | python | {
"resource": ""
} |
q269602 | OptionsProviderMixIn.get_option_def | test | def get_option_def(self, opt):
"""return the dictionary defining an option given its name"""
assert self.options
for option in self.options:
if option[0] == opt:
return option[1]
raise optparse.OptionError(
"no such option %s in section %r" % (opt,... | python | {
"resource": ""
} |
q269603 | OptionsProviderMixIn.options_by_section | test | def options_by_section(self):
"""return an iterator on options grouped by section
(section, [list of (optname, optdict, optvalue)])
"""
sections = {}
for optname, optdict in self.options:
sections.setdefault(optdict.get("group"), []).append(
(optname,... | python | {
"resource": ""
} |
q269604 | is_method_call | test | def is_method_call(func, types=(), methods=()):
"""Determines if a BoundMethod node represents a method call.
Args:
func (astroid.BoundMethod): The BoundMethod AST node to check.
types (Optional[String]): Optional sequence of caller type names to restrict check.
methods (Optional[String]): Op... | python | {
"resource": ""
} |
q269605 | is_complex_format_str | test | def is_complex_format_str(node):
"""Checks if node represents a string with complex formatting specs.
Args:
node (astroid.node_classes.NodeNG): AST node to check
Returns:
bool: True if inferred string uses complex formatting, False otherwise
"""
inferred = utils.safe_infer(node)
... | python | {
"resource": ""
} |
q269606 | LoggingChecker.visit_module | test | def visit_module(self, node): # pylint: disable=unused-argument
"""Clears any state left in this checker from last module checked."""
# The code being checked can just as easily "import logging as foo",
# so it is necessary to process the imports and store in this field
# what name the ... | python | {
"resource": ""
} |
q269607 | LoggingChecker.visit_importfrom | test | def visit_importfrom(self, node):
"""Checks to see if a module uses a non-Python logging module."""
try:
logging_name = self._from_imports[node.modname]
for module, as_name in node.names:
if module == logging_name:
self._logging_names.add(as_na... | python | {
"resource": ""
} |
q269608 | LoggingChecker.visit_import | test | def visit_import(self, node):
"""Checks to see if this module uses Python's built-in logging."""
for module, as_name in node.names:
if module in self._logging_modules:
self._logging_names.add(as_name or module) | python | {
"resource": ""
} |
q269609 | LoggingChecker.visit_call | test | def visit_call(self, node):
"""Checks calls to logging methods."""
def is_logging_name():
return (
isinstance(node.func, astroid.Attribute)
and isinstance(node.func.expr, astroid.Name)
and node.func.expr.name in self._logging_names
... | python | {
"resource": ""
} |
q269610 | LoggingChecker._check_format_string | test | def _check_format_string(self, node, format_arg):
"""Checks that format string tokens match the supplied arguments.
Args:
node (astroid.node_classes.NodeNG): AST node to be checked.
format_arg (int): Index of the format string in the node arguments.
"""
num_args = _c... | python | {
"resource": ""
} |
q269611 | in_loop | test | def in_loop(node):
"""return True if the node is inside a kind of for loop"""
parent = node.parent
while parent is not None:
if isinstance(
parent,
(
astroid.For,
astroid.ListComp,
astroid.SetComp,
astroid.DictCo... | python | {
"resource": ""
} |
q269612 | _get_break_loop_node | test | def _get_break_loop_node(break_node):
"""
Returns the loop node that holds the break node in arguments.
Args:
break_node (astroid.Break): the break node of interest.
Returns:
astroid.For or astroid.While: the loop node holding the break node.
"""
loop_nodes = (astroid.For, astr... | python | {
"resource": ""
} |
q269613 | _loop_exits_early | test | def _loop_exits_early(loop):
"""
Returns true if a loop may ends up in a break statement.
Args:
loop (astroid.For, astroid.While): the loop node inspected.
Returns:
bool: True if the loop may ends up in a break statement, False otherwise.
"""
loop_nodes = (astroid.For, astroid.... | python | {
"resource": ""
} |
q269614 | _get_properties | test | def _get_properties(config):
"""Returns a tuple of property classes and names.
Property classes are fully qualified, such as 'abc.abstractproperty' and
property names are the actual names, such as 'abstract_property'.
"""
property_classes = {BUILTIN_PROPERTY}
property_names = set() # Not retur... | python | {
"resource": ""
} |
q269615 | _determine_function_name_type | test | def _determine_function_name_type(node, config=None):
"""Determine the name type whose regex the a function's name should match.
:param node: A function node.
:type node: astroid.node_classes.NodeNG
:param config: Configuration from which to pull additional property classes.
:type config: :class:`o... | python | {
"resource": ""
} |
q269616 | report_by_type_stats | test | def report_by_type_stats(sect, stats, _):
"""make a report of
* percentage of different types documented
* percentage of different types with a bad name
"""
# percentage of different types documented and/or with a bad name
nice_stats = {}
for node_type in ("module", "class", "method", "func... | python | {
"resource": ""
} |
q269617 | redefined_by_decorator | test | def redefined_by_decorator(node):
"""return True if the object is a method redefined via decorator.
For example:
@property
def x(self): return self._x
@x.setter
def x(self, value): self._x = value
"""
if node.decorators:
for decorator in node.decorators.nodes:
... | python | {
"resource": ""
} |
q269618 | _is_one_arg_pos_call | test | def _is_one_arg_pos_call(call):
"""Is this a call with exactly 1 argument,
where that argument is positional?
"""
return isinstance(call, astroid.Call) and len(call.args) == 1 and not call.keywords | python | {
"resource": ""
} |
q269619 | BasicErrorChecker.visit_starred | test | def visit_starred(self, node):
"""Check that a Starred expression is used in an assignment target."""
if isinstance(node.parent, astroid.Call):
# f(*args) is converted to Call(args=[Starred]), so ignore
# them for this check.
return
if PY35 and isinstance(
... | python | {
"resource": ""
} |
q269620 | BasicErrorChecker._check_nonlocal_and_global | test | def _check_nonlocal_and_global(self, node):
"""Check that a name is both nonlocal and global."""
def same_scope(current):
return current.scope() is node
from_iter = itertools.chain.from_iterable
nonlocals = set(
from_iter(
child.names
... | python | {
"resource": ""
} |
q269621 | BasicErrorChecker.visit_call | test | def visit_call(self, node):
""" Check instantiating abstract class with
abc.ABCMeta as metaclass.
"""
try:
for inferred in node.func.infer():
self._check_inferred_class_is_abstract(inferred, node)
except astroid.InferenceError:
return | python | {
"resource": ""
} |
q269622 | BasicErrorChecker._check_else_on_loop | test | def _check_else_on_loop(self, node):
"""Check that any loop with an else clause has a break statement."""
if node.orelse and not _loop_exits_early(node):
self.add_message(
"useless-else-on-loop",
node=node,
# This is not optimal, but the line p... | python | {
"resource": ""
} |
q269623 | BasicErrorChecker._check_in_loop | test | def _check_in_loop(self, node, node_name):
"""check that a node is inside a for or while loop"""
_node = node.parent
while _node:
if isinstance(_node, (astroid.For, astroid.While)):
if node not in _node.orelse:
return
if isinstance(_no... | python | {
"resource": ""
} |
q269624 | BasicChecker.open | test | def open(self):
"""initialize visit variables and statistics
"""
self._tryfinallys = []
self.stats = self.linter.add_stats(module=0, function=0, method=0, class_=0) | python | {
"resource": ""
} |
q269625 | BasicChecker.visit_expr | test | def visit_expr(self, node):
"""check for various kind of statements without effect"""
expr = node.value
if isinstance(expr, astroid.Const) and isinstance(expr.value, str):
# treat string statement in a separated message
# Handle PEP-257 attribute docstrings.
#... | python | {
"resource": ""
} |
q269626 | BasicChecker.visit_lambda | test | def visit_lambda(self, node):
"""check whether or not the lambda is suspicious
"""
# if the body of the lambda is a call expression with the same
# argument list as the lambda itself, then the lambda is
# possibly unnecessary and at least suspicious.
if node.args.defaults... | python | {
"resource": ""
} |
q269627 | BasicChecker.visit_assert | test | def visit_assert(self, node):
"""check the use of an assert statement on a tuple."""
if (
node.fail is None
and isinstance(node.test, astroid.Tuple)
and len(node.test.elts) == 2
):
self.add_message("assert-on-tuple", node=node) | python | {
"resource": ""
} |
q269628 | BasicChecker.visit_dict | test | def visit_dict(self, node):
"""check duplicate key in dictionary"""
keys = set()
for k, _ in node.items:
if isinstance(k, astroid.Const):
key = k.value
if key in keys:
self.add_message("duplicate-key", node=node, args=key)
... | python | {
"resource": ""
} |
q269629 | BasicChecker._check_unreachable | test | def _check_unreachable(self, node):
"""check unreachable code"""
unreach_stmt = node.next_sibling()
if unreach_stmt is not None:
self.add_message("unreachable", node=unreach_stmt) | python | {
"resource": ""
} |
q269630 | BasicChecker._check_not_in_finally | test | def _check_not_in_finally(self, node, node_name, breaker_classes=()):
"""check that a node is not inside a finally clause of a
try...finally statement.
If we found before a try...finally bloc a parent which its type is
in breaker_classes, we skip the whole check."""
# if self._tr... | python | {
"resource": ""
} |
q269631 | BasicChecker._check_reversed | test | def _check_reversed(self, node):
""" check that the argument to `reversed` is a sequence """
try:
argument = utils.safe_infer(utils.get_argument_from_call(node, position=0))
except utils.NoSuchArgumentError:
pass
else:
if argument is astroid.Uninferabl... | python | {
"resource": ""
} |
q269632 | NameChecker.visit_assignname | test | def visit_assignname(self, node):
"""check module level assigned names"""
self._check_assign_to_new_keyword_violation(node.name, node)
frame = node.frame()
assign_type = node.assign_type()
if isinstance(assign_type, astroid.Comprehension):
self._check_name("inlinevar"... | python | {
"resource": ""
} |
q269633 | NameChecker._check_name | test | def _check_name(self, node_type, name, node, confidence=interfaces.HIGH):
"""check for a name using the type's regexp"""
def _should_exempt_from_invalid_name(node):
if node_type == "variable":
inferred = utils.safe_infer(node)
if isinstance(inferred, astroid.... | python | {
"resource": ""
} |
q269634 | DocStringChecker._check_docstring | test | def _check_docstring(
self, node_type, node, report_missing=True, confidence=interfaces.HIGH
):
"""check the node has a non empty docstring"""
docstring = node.doc
if docstring is None:
if not report_missing:
return
lines = utils.get_node_last_... | python | {
"resource": ""
} |
q269635 | ComparisonChecker._check_literal_comparison | test | def _check_literal_comparison(self, literal, node):
"""Check if we compare to a literal, which is usually what we do not want to do."""
nodes = (astroid.List, astroid.Tuple, astroid.Dict, astroid.Set)
is_other_literal = isinstance(literal, nodes)
is_const = False
if isinstance(li... | python | {
"resource": ""
} |
q269636 | PathGraphingAstVisitor._subgraph | test | def _subgraph(self, node, name, extra_blocks=()):
"""create the subgraphs representing any `if` and `for` statements"""
if self.graph is None:
# global loop
self.graph = PathGraph(node)
self._subgraph_parse(node, node, extra_blocks)
self.graphs["%s%s" % (s... | python | {
"resource": ""
} |
q269637 | PathGraphingAstVisitor._subgraph_parse | test | def _subgraph_parse(
self, node, pathnode, extra_blocks
): # pylint: disable=unused-argument
"""parse the body and any `else` block of `if` and `for` statements"""
loose_ends = []
self.tail = node
self.dispatch_list(node.body)
loose_ends.append(self.tail)
for... | python | {
"resource": ""
} |
q269638 | McCabeMethodChecker.visit_module | test | def visit_module(self, node):
"""visit an astroid.Module node to check too complex rating and
add message if is greather than max_complexity stored from options"""
visitor = PathGraphingAstVisitor()
for child in node.body:
visitor.preorder(child, visitor)
for graph in... | python | {
"resource": ""
} |
q269639 | ASTWalker.add_checker | test | def add_checker(self, checker):
"""walk to the checker's dir and collect visit and leave methods"""
# XXX : should be possible to merge needed_checkers and add_checker
vcids = set()
lcids = set()
visits = self.visit_events
leaves = self.leave_events
for member in ... | python | {
"resource": ""
} |
q269640 | ASTWalker.walk | test | def walk(self, astroid):
"""call visit events of astroid checkers for the given node, recurse on
its children, then leave events.
"""
cid = astroid.__class__.__name__.lower()
# Detect if the node is a new name for a deprecated alias.
# In this case, favour the methods fo... | python | {
"resource": ""
} |
q269641 | ClassDiagram.add_relationship | test | def add_relationship(self, from_object, to_object, relation_type, name=None):
"""create a relation ship
"""
rel = Relationship(from_object, to_object, relation_type, name)
self.relationships.setdefault(relation_type, []).append(rel) | python | {
"resource": ""
} |
q269642 | ClassDiagram.get_relationship | test | def get_relationship(self, from_object, relation_type):
"""return a relation ship or None
"""
for rel in self.relationships.get(relation_type, ()):
if rel.from_object is from_object:
return rel
raise KeyError(relation_type) | python | {
"resource": ""
} |
q269643 | ClassDiagram.get_attrs | test | def get_attrs(self, node):
"""return visible attributes, possibly with class name"""
attrs = []
properties = [
(n, m)
for n, m in node.items()
if isinstance(m, astroid.FunctionDef) and decorated_with_property(m)
]
for node_name, associated_node... | python | {
"resource": ""
} |
q269644 | ClassDiagram.get_methods | test | def get_methods(self, node):
"""return visible methods"""
methods = [
m
for m in node.values()
if isinstance(m, astroid.FunctionDef)
and not decorated_with_property(m)
and self.show_attr(m.name)
]
return sorted(methods, key=lamb... | python | {
"resource": ""
} |
q269645 | ClassDiagram.add_object | test | def add_object(self, title, node):
"""create a diagram object
"""
assert node not in self._nodes
ent = DiagramEntity(title, node)
self._nodes[node] = ent
self.objects.append(ent) | python | {
"resource": ""
} |
q269646 | ClassDiagram.class_names | test | def class_names(self, nodes):
"""return class names if needed in diagram"""
names = []
for node in nodes:
if isinstance(node, astroid.Instance):
node = node._proxied
if (
isinstance(node, astroid.ClassDef)
and hasattr(node, ... | python | {
"resource": ""
} |
q269647 | ClassDiagram.classes | test | def classes(self):
"""return all class nodes in the diagram"""
return [o for o in self.objects if isinstance(o.node, astroid.ClassDef)] | python | {
"resource": ""
} |
q269648 | ClassDiagram.classe | test | def classe(self, name):
"""return a class by its name, raise KeyError if not found
"""
for klass in self.classes():
if klass.node.name == name:
return klass
raise KeyError(name) | python | {
"resource": ""
} |
q269649 | PackageDiagram.modules | test | def modules(self):
"""return all module nodes in the diagram"""
return [o for o in self.objects if isinstance(o.node, astroid.Module)] | python | {
"resource": ""
} |
q269650 | PackageDiagram.module | test | def module(self, name):
"""return a module by its name, raise KeyError if not found
"""
for mod in self.modules():
if mod.node.name == name:
return mod
raise KeyError(name) | python | {
"resource": ""
} |
q269651 | PackageDiagram.get_module | test | def get_module(self, name, node):
"""return a module by its name, looking also for relative imports;
raise KeyError if not found
"""
for mod in self.modules():
mod_name = mod.node.name
if mod_name == name:
return mod
# search for fullna... | python | {
"resource": ""
} |
q269652 | PackageDiagram.add_from_depend | test | def add_from_depend(self, node, from_module):
"""add dependencies created by from-imports
"""
mod_name = node.root().name
obj = self.module(mod_name)
if from_module not in obj.node.depends:
obj.node.depends.append(from_module) | python | {
"resource": ""
} |
q269653 | Grant.delete | test | def delete(self):
"""Removes itself from the cache
Note: This is required by the oauthlib
"""
log.debug(
"Deleting grant %s for client %s" % (self.code, self.client_id)
)
self._cache.delete(self.key)
return None | python | {
"resource": ""
} |
q269654 | BaseBinding.query | test | def query(self):
"""Determines which method of getting the query object for use"""
if hasattr(self.model, 'query'):
return self.model.query
else:
return self.session.query(self.model) | python | {
"resource": ""
} |
q269655 | UserBinding.get | test | def get(self, username, password, *args, **kwargs):
"""Returns the User object
Returns None if the user isn't found or the passwords don't match
:param username: username of the user
:param password: password of the user
"""
user = self.query.filter_by(username=username... | python | {
"resource": ""
} |
q269656 | TokenBinding.get | test | def get(self, access_token=None, refresh_token=None):
"""returns a Token object with the given access token or refresh token
:param access_token: User's access token
:param refresh_token: User's refresh token
"""
if access_token:
return self.query.filter_by(access_to... | python | {
"resource": ""
} |
q269657 | TokenBinding.set | test | def set(self, token, request, *args, **kwargs):
"""Creates a Token object and removes all expired tokens that belong
to the user
:param token: token object
:param request: OAuthlib request object
"""
if hasattr(request, 'user') and request.user:
user = reques... | python | {
"resource": ""
} |
q269658 | GrantBinding.set | test | def set(self, client_id, code, request, *args, **kwargs):
"""Creates Grant object with the given params
:param client_id: ID of the client
:param code:
:param request: OAuthlib request object
"""
expires = datetime.utcnow() + timedelta(seconds=100)
grant = self.m... | python | {
"resource": ""
} |
q269659 | GrantBinding.get | test | def get(self, client_id, code):
"""Get the Grant object with the given client ID and code
:param client_id: ID of the client
:param code:
"""
return self.query.filter_by(client_id=client_id, code=code).first() | python | {
"resource": ""
} |
q269660 | prepare_request | test | def prepare_request(uri, headers=None, data=None, method=None):
"""Make request parameters right."""
if headers is None:
headers = {}
if data and not method:
method = 'POST'
elif not method:
method = 'GET'
if method == 'GET' and data:
uri = add_params_to_uri(uri, da... | python | {
"resource": ""
} |
q269661 | OAuth.init_app | test | def init_app(self, app):
"""Init app with Flask instance.
You can also pass the instance of Flask later::
oauth = OAuth()
oauth.init_app(app)
"""
self.app = app
app.extensions = getattr(app, 'extensions', {})
app.extensions[self.state_key] = self | python | {
"resource": ""
} |
q269662 | OAuth.remote_app | test | def remote_app(self, name, register=True, **kwargs):
"""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`.
"""
remote = OAuthRe... | python | {
"resource": ""
} |
q269663 | OAuthRemoteApp.request | test | def request(self, url, data=None, headers=None, format='urlencoded',
method='GET', content_type=None, token=None):
"""
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 ... | python | {
"resource": ""
} |
q269664 | OAuthRemoteApp.authorize | test | def authorize(self, callback=None, state=None, **kwargs):
"""
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.
... | python | {
"resource": ""
} |
q269665 | OAuthRemoteApp.handle_oauth1_response | test | def handle_oauth1_response(self, args):
"""Handles an oauth1 authorization response."""
client = self.make_client()
client.verifier = args.get('oauth_verifier')
tup = session.get('%s_oauthtok' % self.name)
if not tup:
raise OAuthException(
'Token not f... | python | {
"resource": ""
} |
q269666 | OAuthRemoteApp.handle_oauth2_response | test | def handle_oauth2_response(self, args):
"""Handles an oauth2 authorization response."""
client = self.make_client()
remote_args = {
'code': args.get('code'),
'client_secret': self.consumer_secret,
'redirect_uri': session.get('%s_oauthredir' % self.name)
... | python | {
"resource": ""
} |
q269667 | OAuthRemoteApp.authorized_response | test | def authorized_response(self, args=None):
"""Handles authorization response smartly."""
if args is None:
args = request.args
if 'oauth_verifier' in args:
data = self.handle_oauth1_response(args)
elif 'code' in args:
data = self.handle_oauth2_response(a... | python | {
"resource": ""
} |
q269668 | OAuthRemoteApp.authorized_handler | test | def authorized_handler(self, f):
"""Handles an OAuth callback.
.. versionchanged:: 0.7
@authorized_handler is deprecated in favor of authorized_response.
"""
@wraps(f)
def decorated(*args, **kwargs):
log.warn(
'@authorized_handler is deprec... | python | {
"resource": ""
} |
q269669 | _hash_token | test | def _hash_token(application, token):
"""Creates a hashable object for given token then we could use it as a
dictionary key.
"""
if isinstance(token, dict):
hashed_token = tuple(sorted(token.items()))
elif isinstance(token, tuple):
hashed_token = token
else:
raise TypeErro... | python | {
"resource": ""
} |
q269670 | BaseApplication._make_client_with_token | test | def _make_client_with_token(self, token):
"""Uses cached client or create new one with specific token."""
cached_clients = getattr(self, 'clients', None)
hashed_token = _hash_token(self, token)
if cached_clients and hashed_token in cached_clients:
return cached_clients[hashe... | python | {
"resource": ""
} |
q269671 | OAuth1Application.make_client | test | def make_client(self, token):
"""Creates a client with specific access token pair.
:param token: a tuple of access token pair ``(token, token_secret)``
or a dictionary of access token response.
:returns: a :class:`requests_oauthlib.oauth1_session.OAuth1Session`
... | python | {
"resource": ""
} |
q269672 | OAuth2Application.insecure_transport | test | def insecure_transport(self):
"""Creates a context to enable the oauthlib environment variable in
order to debug with insecure transport.
"""
origin = os.environ.get('OAUTHLIB_INSECURE_TRANSPORT')
if current_app.debug or current_app.testing:
try:
os.en... | python | {
"resource": ""
} |
q269673 | OAuth1Provider.confirm_authorization_request | test | def confirm_authorization_request(self):
"""When consumer confirm the authrozation."""
server = self.server
uri, http_method, body, headers = extract_params()
try:
realms, credentials = server.get_realms_and_credentials(
uri, http_method=http_method, body=bod... | python | {
"resource": ""
} |
q269674 | OAuth1Provider.request_token_handler | test | def request_token_handler(self, f):
"""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::
@... | python | {
"resource": ""
} |
q269675 | OAuth1RequestValidator.get_client_secret | test | def get_client_secret(self, client_key, request):
"""Get client secret.
The client object must has ``client_secret`` attribute.
"""
log.debug('Get client secret of %r', client_key)
if not request.client:
request.client = self._clientgetter(client_key=client_key)
... | python | {
"resource": ""
} |
q269676 | OAuth1RequestValidator.get_request_token_secret | test | def get_request_token_secret(self, client_key, token, request):
"""Get request token secret.
The request token object should a ``secret`` attribute.
"""
log.debug('Get request token secret of %r for %r',
token, client_key)
tok = request.request_token or self._g... | python | {
"resource": ""
} |
q269677 | OAuth1RequestValidator.get_access_token_secret | test | def get_access_token_secret(self, client_key, token, request):
"""Get access token secret.
The access token object should a ``secret`` attribute.
"""
log.debug('Get access token secret of %r for %r',
token, client_key)
tok = request.access_token or self._tokeng... | python | {
"resource": ""
} |
q269678 | OAuth1RequestValidator.get_default_realms | test | def get_default_realms(self, client_key, request):
"""Default realms of the client."""
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_re... | python | {
"resource": ""
} |
q269679 | OAuth1RequestValidator.get_realms | test | def get_realms(self, token, request):
"""Realms for this request token."""
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'):
... | python | {
"resource": ""
} |
q269680 | OAuth1RequestValidator.get_redirect_uri | test | def get_redirect_uri(self, token, request):
"""Redirect uri for this request token."""
log.debug('Get redirect uri of %r', token)
tok = request.request_token or self._grantgetter(token=token)
return tok.redirect_uri | python | {
"resource": ""
} |
q269681 | OAuth1RequestValidator.get_rsa_key | test | def get_rsa_key(self, client_key, request):
"""Retrieves a previously stored client provided RSA key."""
if not request.client:
request.client = self._clientgetter(client_key=client_key)
if hasattr(request.client, 'rsa_key'):
return request.client.rsa_key
return N... | python | {
"resource": ""
} |
q269682 | OAuth1RequestValidator.validate_client_key | test | def validate_client_key(self, client_key, request):
"""Validates that supplied client key."""
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
... | python | {
"resource": ""
} |
q269683 | OAuth1RequestValidator.validate_request_token | test | def validate_request_token(self, client_key, token, request):
"""Validates request token is available for client."""
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 ... | python | {
"resource": ""
} |
q269684 | OAuth1RequestValidator.validate_access_token | test | def validate_access_token(self, client_key, token, request):
"""Validates access token is available for client."""
log.debug('Validate access token %r for %r',
token, client_key)
tok = request.access_token or self._tokengetter(
client_key=client_key,
tok... | python | {
"resource": ""
} |
q269685 | OAuth1RequestValidator.validate_timestamp_and_nonce | test | def validate_timestamp_and_nonce(self, client_key, timestamp, nonce,
request, request_token=None,
access_token=None):
"""Validate the timestamp and nonce is used or not."""
log.debug('Validate timestamp and nonce %r', client_key)
... | python | {
"resource": ""
} |
q269686 | OAuth1RequestValidator.validate_redirect_uri | test | def validate_redirect_uri(self, client_key, redirect_uri, request):
"""Validate if the redirect_uri is allowed by the client."""
log.debug('Validate redirect_uri %r for %r', redirect_uri, client_key)
if not request.client:
request.client = self._clientgetter(client_key=client_key)
... | python | {
"resource": ""
} |
q269687 | OAuth1RequestValidator.validate_realms | test | def validate_realms(self, client_key, token, request, uri=None,
realms=None):
"""Check if the token has permission on those realms."""
log.debug('Validate realms %r for %r', realms, client_key)
if request.access_token:
tok = request.access_token
else:
... | python | {
"resource": ""
} |
q269688 | OAuth1RequestValidator.validate_verifier | test | def validate_verifier(self, client_key, token, verifier, request):
"""Validate verifier exists."""
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,... | python | {
"resource": ""
} |
q269689 | OAuth1RequestValidator.verify_request_token | test | def verify_request_token(self, token, request):
"""Verify if the request token is existed."""
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 F... | python | {
"resource": ""
} |
q269690 | OAuth1RequestValidator.verify_realms | test | def verify_realms(self, token, realms, request):
"""Verify if the realms match the requested realms."""
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... | python | {
"resource": ""
} |
q269691 | OAuth1RequestValidator.save_access_token | test | def save_access_token(self, token, request):
"""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,
... | python | {
"resource": ""
} |
q269692 | OAuth1RequestValidator.save_request_token | test | def save_request_token(self, 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'],
... | python | {
"resource": ""
} |
q269693 | OAuth1RequestValidator.save_verifier | test | def save_verifier(self, token, verifier, request):
"""Save verifier to database.
A verifiersetter is required. It would be better to combine request
token and verifier together::
def verifiersetter(token, verifier, request):
tok = Grant.query.filter_by(token=token).... | python | {
"resource": ""
} |
q269694 | OAuth2Provider.error_uri | test | def error_uri(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::
... | python | {
"resource": ""
} |
q269695 | OAuth2Provider.confirm_authorization_request | test | def confirm_authorization_request(self):
"""When consumer confirm the authorization."""
server = self.server
scope = request.values.get('scope') or ''
scopes = scope.split()
credentials = dict(
client_id=request.values.get('client_id'),
redirect_uri=reques... | python | {
"resource": ""
} |
q269696 | OAuth2Provider.verify_request | test | def verify_request(self, scopes):
"""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... | python | {
"resource": ""
} |
q269697 | OAuth2RequestValidator._get_client_creds_from_request | test | def _get_client_creds_from_request(self, request):
"""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 enc... | python | {
"resource": ""
} |
q269698 | OAuth2RequestValidator.client_authentication_required | test | def client_authentication_required(self, request, *args, **kwargs):
"""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`_... | python | {
"resource": ""
} |
q269699 | OAuth2RequestValidator.authenticate_client | test | def authenticate_client(self, request, *args, **kwargs):
"""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
"""
client_id, client_secret = self._get_client_creds_from_r... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.