_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q269500 | ScopeAccessMap.set_accessed | test | def set_accessed(self, node):
"""Set the given node as accessed."""
frame = node_frame_class(node)
if frame is None:
# The node does not live in a class.
return
self._scopes[frame][node.attrname].append(node) | python | {
"resource": ""
} |
q269501 | ClassChecker.visit_classdef | test | def visit_classdef(self, node):
"""init visit variable _accessed
"""
self._check_bases_classes(node)
# if not an exception or a metaclass
if node.type == "class" and has_known_bases(node):
try:
node.local_attr("__init__")
except astroid.Not... | python | {
"resource": ""
} |
q269502 | ClassChecker._check_consistent_mro | test | def _check_consistent_mro(self, node):
"""Detect that a class has a consistent mro or duplicate bases."""
try:
node.mro()
except InconsistentMroError:
self.add_message("inconsistent-mro", args=node.name, node=node)
except DuplicateBasesError:
self.add_... | python | {
"resource": ""
} |
q269503 | ClassChecker._check_proper_bases | test | def _check_proper_bases(self, node):
"""
Detect that a class inherits something which is not
a class or a type.
"""
for base in node.bases:
ancestor = safe_infer(base)
if ancestor in (astroid.Uninferable, None):
continue
if isin... | python | {
"resource": ""
} |
q269504 | ClassChecker.visit_functiondef | test | def visit_functiondef(self, node):
"""check method arguments, overriding"""
# ignore actual functions
if not node.is_method():
return
self._check_useless_super_delegation(node)
klass = node.parent.frame()
self._meth_could_be_func = True
# check first... | python | {
"resource": ""
} |
q269505 | ClassChecker._check_useless_super_delegation | test | def _check_useless_super_delegation(self, function):
"""Check if the given function node is an useless method override
We consider it *useless* if it uses the super() builtin, but having
nothing additional whatsoever than not implementing the method at all.
If the method uses super() to... | python | {
"resource": ""
} |
q269506 | ClassChecker.leave_functiondef | test | def leave_functiondef(self, node):
"""on method node, check if this method couldn't be a function
ignore class, static and abstract methods, initializer,
methods overridden from a parent class.
"""
if node.is_method():
if node.args.args is not None:
s... | python | {
"resource": ""
} |
q269507 | ClassChecker._check_in_slots | test | def _check_in_slots(self, node):
""" Check that the given AssignAttr node
is defined in the class slots.
"""
inferred = safe_infer(node.expr)
if not isinstance(inferred, astroid.Instance):
return
klass = inferred._proxied
if not has_known_bases(klass)... | python | {
"resource": ""
} |
q269508 | ClassChecker.visit_name | test | def visit_name(self, node):
"""check if the name handle an access to a class member
if so, register it
"""
if self._first_attrs and (
node.name == self._first_attrs[-1] or not self._first_attrs[-1]
):
self._meth_could_be_func = False | python | {
"resource": ""
} |
q269509 | ClassChecker._check_accessed_members | test | def _check_accessed_members(self, node, accessed):
"""check that accessed members are defined"""
# XXX refactor, probably much simpler now that E0201 is in type checker
excs = ("AttributeError", "Exception", "BaseException")
for attr, nodes in accessed.items():
try:
... | python | {
"resource": ""
} |
q269510 | ClassChecker._check_bases_classes | test | def _check_bases_classes(self, node):
"""check that the given class node implements abstract methods from
base classes
"""
def is_abstract(method):
return method.is_abstract(pass_is_abstract=False)
# check if this class abstract
if class_is_abstract(node):
... | python | {
"resource": ""
} |
q269511 | ClassChecker._check_signature | test | def _check_signature(self, method1, refmethod, class_type, cls):
"""check that the signature of the two given methods match
"""
if not (
isinstance(method1, astroid.FunctionDef)
and isinstance(refmethod, astroid.FunctionDef)
):
self.add_message(
... | python | {
"resource": ""
} |
q269512 | ClassChecker._is_mandatory_method_param | test | def _is_mandatory_method_param(self, node):
"""Check if astroid.Name corresponds to first attribute variable name
Name is `self` for method, `cls` for classmethod and `mcs` for metaclass.
"""
return (
self._first_attrs
and isinstance(node, astroid.Name)
... | python | {
"resource": ""
} |
q269513 | _is_raising | test | def _is_raising(body: typing.List) -> bool:
"""Return true if the given statement node raise an exception"""
for node in body:
if isinstance(node, astroid.Raise):
return True
return False | python | {
"resource": ""
} |
q269514 | ExceptionsChecker._check_bad_exception_context | test | def _check_bad_exception_context(self, node):
"""Verify that the exception context is properly set.
An exception context can be only `None` or an exception.
"""
cause = utils.safe_infer(node.cause)
if cause in (astroid.Uninferable, None):
return
if isinstanc... | python | {
"resource": ""
} |
q269515 | NewStyleConflictChecker.visit_functiondef | test | def visit_functiondef(self, node):
"""check use of super"""
# ignore actual functions or method within a new style class
if not node.is_method():
return
klass = node.parent.frame()
for stmt in node.nodes_of_class(astroid.Call):
if node_frame_class(stmt) !=... | python | {
"resource": ""
} |
q269516 | BaseReporter.display_reports | test | def display_reports(self, layout):
"""display results encapsulated in the layout tree"""
self.section = 0
if hasattr(layout, "report_id"):
layout.children[0].children[0].data += " (%s)" % layout.report_id
self._display(layout) | python | {
"resource": ""
} |
q269517 | _is_typing_namedtuple | test | def _is_typing_namedtuple(node: astroid.ClassDef) -> bool:
"""Check if a class node is a typing.NamedTuple class"""
for base in node.ancestors():
if base.qname() == TYPING_NAMEDTUPLE:
return True
return False | python | {
"resource": ""
} |
q269518 | _is_enum_class | test | def _is_enum_class(node: astroid.ClassDef) -> bool:
"""Check if a class definition defines an Enum class.
:param node: The class node to check.
:type node: astroid.ClassDef
:returns: True if the given node represents an Enum class. False otherwise.
:rtype: bool
"""
for base in node.bases:
... | python | {
"resource": ""
} |
q269519 | _is_dataclass | test | def _is_dataclass(node: astroid.ClassDef) -> bool:
"""Check if a class definition defines a Python 3.7+ dataclass
:param node: The class node to check.
:type node: astroid.ClassDef
:returns: True if the given node represents a dataclass class. False otherwise.
:rtype: bool
"""
if not node.... | python | {
"resource": ""
} |
q269520 | MisdesignChecker.open | test | def open(self):
"""initialize visit variables"""
self.stats = self.linter.add_stats()
self._returns = []
self._branches = defaultdict(int)
self._stmts = [] | python | {
"resource": ""
} |
q269521 | MisdesignChecker.visit_classdef | test | def visit_classdef(self, node):
"""check size of inheritance hierarchy and number of instance attributes
"""
nb_parents = len(list(node.ancestors()))
if nb_parents > self.config.max_parents:
self.add_message(
"too-many-ancestors",
node=node,
... | python | {
"resource": ""
} |
q269522 | MisdesignChecker.leave_classdef | test | def leave_classdef(self, node):
"""check number of public methods"""
my_methods = sum(
1 for method in node.mymethods() if not method.name.startswith("_")
)
# Does the class contain less than n public methods ?
# This checks only the methods defined in the current cl... | python | {
"resource": ""
} |
q269523 | MisdesignChecker.visit_if | test | def visit_if(self, node):
"""increments the branches counter and checks boolean expressions"""
self._check_boolean_expressions(node)
branches = 1
# don't double count If nodes coming from some 'elif'
if node.orelse and (len(node.orelse) > 1 or not isinstance(node.orelse[0], If)):... | python | {
"resource": ""
} |
q269524 | MisdesignChecker._check_boolean_expressions | test | def _check_boolean_expressions(self, node):
"""Go through "if" node `node` and counts its boolean expressions
if the "if" node test is a BoolOp node
"""
condition = node.test
if not isinstance(condition, BoolOp):
return
nb_bool_expr = _count_boolean_expressio... | python | {
"resource": ""
} |
q269525 | SpellingChecker._check_docstring | test | def _check_docstring(self, node):
"""check the node has any spelling errors"""
docstring = node.doc
if not docstring:
return
start_line = node.lineno + 1
# Go through lines of docstring
for idx, line in enumerate(docstring.splitlines()):
self._ch... | python | {
"resource": ""
} |
q269526 | Message.format | test | def format(self, template):
"""Format the message according to the given template.
The template format is the one of the format method :
cf. http://docs.python.org/2/library/string.html#formatstrings
"""
# For some reason, _asdict on derived namedtuples does not work with
... | python | {
"resource": ""
} |
q269527 | _is_trailing_comma | test | def _is_trailing_comma(tokens, index):
"""Check if the given token is a trailing comma
:param tokens: Sequence of modules tokens
:type tokens: list[tokenize.TokenInfo]
:param int index: Index of token under check in tokens
:returns: True if the token is a comma which trails an expression
:rtype... | python | {
"resource": ""
} |
q269528 | RefactoringChecker._is_actual_elif | test | def _is_actual_elif(self, node):
"""Check if the given node is an actual elif
This is a problem we're having with the builtin ast module,
which splits `elif` branches into a separate if statement.
Unfortunately we need to know the exact type in certain
cases.
"""
... | python | {
"resource": ""
} |
q269529 | RefactoringChecker._check_simplifiable_if | test | def _check_simplifiable_if(self, node):
"""Check if the given if node can be simplified.
The if statement can be reduced to a boolean expression
in some cases. For instance, if there are two branches
and both of them return a boolean value that depends on
the result of the state... | python | {
"resource": ""
} |
q269530 | RefactoringChecker._check_stop_iteration_inside_generator | test | def _check_stop_iteration_inside_generator(self, node):
"""Check if an exception of type StopIteration is raised inside a generator"""
frame = node.frame()
if not isinstance(frame, astroid.FunctionDef) or not frame.is_generator():
return
if utils.node_ignores_exception(node, ... | python | {
"resource": ""
} |
q269531 | RefactoringChecker._check_exception_inherit_from_stopiteration | test | def _check_exception_inherit_from_stopiteration(exc):
"""Return True if the exception node in argument inherit from StopIteration"""
stopiteration_qname = "{}.StopIteration".format(utils.EXCEPTIONS_MODULE)
return any(_class.qname() == stopiteration_qname for _class in exc.mro()) | python | {
"resource": ""
} |
q269532 | RefactoringChecker._check_raising_stopiteration_in_generator_next_call | test | def _check_raising_stopiteration_in_generator_next_call(self, node):
"""Check if a StopIteration exception is raised by the call to next function
If the next value has a default value, then do not add message.
:param node: Check to see if this Call node is a next function
:type node: :... | python | {
"resource": ""
} |
q269533 | RefactoringChecker._check_nested_blocks | test | def _check_nested_blocks(self, node):
"""Update and check the number of nested blocks
"""
# only check block levels inside functions or methods
if not isinstance(node.scope(), astroid.FunctionDef):
return
# messages are triggered on leaving the nested block. Here we s... | python | {
"resource": ""
} |
q269534 | RefactoringChecker._duplicated_isinstance_types | test | def _duplicated_isinstance_types(node):
"""Get the duplicated types from the underlying isinstance calls.
:param astroid.BoolOp node: Node which should contain a bunch of isinstance calls.
:returns: Dictionary of the comparison objects from the isinstance calls,
to duplicate v... | python | {
"resource": ""
} |
q269535 | RefactoringChecker._check_consider_merging_isinstance | test | def _check_consider_merging_isinstance(self, node):
"""Check isinstance calls which can be merged together."""
if node.op != "or":
return
first_args = self._duplicated_isinstance_types(node)
for duplicated_name, class_names in first_args.items():
names = sorted(n... | python | {
"resource": ""
} |
q269536 | RefactoringChecker._check_chained_comparison | test | def _check_chained_comparison(self, node):
"""Check if there is any chained comparison in the expression.
Add a refactoring message if a boolOp contains comparison like a < b and b < c,
which can be chained as a < b < c.
Care is taken to avoid simplifying a < b < c and b < d.
"... | python | {
"resource": ""
} |
q269537 | RefactoringChecker._is_and_or_ternary | test | def _is_and_or_ternary(node):
"""
Returns true if node is 'condition and true_value or false_value' form.
All of: condition, true_value and false_value should not be a complex boolean expression
"""
return (
isinstance(node, astroid.BoolOp)
and node.op ==... | python | {
"resource": ""
} |
q269538 | RefactoringChecker._check_consistent_returns | test | def _check_consistent_returns(self, node):
"""Check that all return statements inside a function are consistent.
Return statements are consistent if:
- all returns are explicit and if there is no implicit return;
- all returns are empty and if there is, possibly, an implicit ret... | python | {
"resource": ""
} |
q269539 | RefactoringChecker._is_node_return_ended | test | def _is_node_return_ended(self, node):
"""Check if the node ends with an explicit return statement.
Args:
node (astroid.NodeNG): node to be checked.
Returns:
bool: True if the node ends with an explicit statement, False otherwise.
"""
# Recursion base ... | python | {
"resource": ""
} |
q269540 | RecommandationChecker.visit_for | test | def visit_for(self, node):
"""Emit a convention whenever range and len are used for indexing."""
# Verify that we have a `range([start], len(...), [stop])` call and
# that the object which is iterated is used as a subscript in the
# body of the for.
# Is it a proper range call?
... | python | {
"resource": ""
} |
q269541 | _check_graphviz_available | test | def _check_graphviz_available(output_format):
"""check if we need graphviz for different output format"""
try:
subprocess.call(["dot", "-V"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
except OSError:
print(
"The output format '%s' is currently not available.\n"
... | python | {
"resource": ""
} |
q269542 | Run.run | test | def run(self, args):
"""checking arguments and run project"""
if not args:
print(self.help())
return 1
# insert current working directory to the python path to recognize
# dependencies to local modules even if cwd is not in the PYTHONPATH
sys.path.insert(0... | python | {
"resource": ""
} |
q269543 | DiagramWriter.write_packages | test | def write_packages(self, diagram):
"""write a package diagram"""
# sorted to get predictable (hence testable) results
for i, obj in enumerate(sorted(diagram.modules(), key=lambda x: x.title)):
self.printer.emit_node(i, label=self.get_title(obj), shape="box")
obj.fig_id = ... | python | {
"resource": ""
} |
q269544 | DiagramWriter.write_classes | test | def write_classes(self, diagram):
"""write a class diagram"""
# sorted to get predictable (hence testable) results
for i, obj in enumerate(sorted(diagram.objects, key=lambda x: x.title)):
self.printer.emit_node(i, **self.get_values(obj))
obj.fig_id = i
# inheritan... | python | {
"resource": ""
} |
q269545 | DotWriter.set_printer | test | def set_printer(self, file_name, basename):
"""initialize DotWriter and add options for layout.
"""
layout = dict(rankdir="BT")
self.printer = DotBackend(basename, additional_param=layout)
self.file_name = file_name | python | {
"resource": ""
} |
q269546 | VCGWriter.set_printer | test | def set_printer(self, file_name, basename):
"""initialize VCGWriter for a UML graph"""
self.graph_file = open(file_name, "w+")
self.printer = VCGPrinter(self.graph_file)
self.printer.open_graph(
title=basename,
layoutalgorithm="dfs",
late_edge_labels="... | python | {
"resource": ""
} |
q269547 | MessageDefinition.may_be_emitted | test | def may_be_emitted(self):
"""return True if message may be emitted using the current interpreter"""
if self.minversion is not None and self.minversion > sys.version_info:
return False
if self.maxversion is not None and self.maxversion <= sys.version_info:
return False
... | python | {
"resource": ""
} |
q269548 | MessageDefinition.format_help | test | def format_help(self, checkerref=False):
"""return the help string for the given message id"""
desc = self.descr
if checkerref:
desc += " This message belongs to the %s checker." % self.checker.name
title = self.msg
if self.symbol:
msgid = "%s (%s)" % (sel... | python | {
"resource": ""
} |
q269549 | _get_env | test | def _get_env():
"""Extracts the environment PYTHONPATH and appends the current sys.path to
those."""
env = dict(os.environ)
env["PYTHONPATH"] = os.pathsep.join(sys.path)
return env | python | {
"resource": ""
} |
q269550 | lint | test | def lint(filename, options=()):
"""Pylint the given file.
When run from emacs we will be in the directory of a file, and passed its
filename. If this file is part of a package and is trying to import other
modules from within its own package or another package rooted in a directory
below it, pylin... | python | {
"resource": ""
} |
q269551 | py_run | test | def py_run(command_options="", return_std=False, stdout=None, stderr=None):
"""Run pylint from python
``command_options`` is a string containing ``pylint`` command line options;
``return_std`` (boolean) indicates return of created standard output
and error (see below);
``stdout`` and ``stderr`` are... | python | {
"resource": ""
} |
q269552 | _get_cycles | test | def _get_cycles(graph_dict, path, visited, result, vertice):
"""recursive function doing the real work for get_cycles"""
if vertice in path:
cycle = [vertice]
for node in path[::-1]:
if node == vertice:
break
cycle.insert(0, node)
# make a canonica... | python | {
"resource": ""
} |
q269553 | DotBackend.get_source | test | def get_source(self):
"""returns self._source"""
if self._source is None:
self.emit("}\n")
self._source = "\n".join(self.lines)
del self.lines
return self._source | python | {
"resource": ""
} |
q269554 | DotBackend.generate | test | def generate(self, outputfile=None, dotfile=None, mapfile=None):
"""Generates a graph file.
:param str outputfile: filename and path [defaults to graphname.png]
:param str dotfile: filename and path [defaults to graphname.dot]
:param str mapfile: filename and path
:rtype: str
... | python | {
"resource": ""
} |
q269555 | _rest_format_section | test | def _rest_format_section(stream, section, options, doc=None):
"""format an options section using as ReST formatted output"""
if section:
print("%s\n%s" % (section, "'" * len(section)), file=stream)
if doc:
print(normalize_text(doc, line_len=79, indent=""), file=stream)
print(file=str... | python | {
"resource": ""
} |
q269556 | MessagesHandlerMixIn._register_by_id_managed_msg | test | def _register_by_id_managed_msg(self, msgid, line, is_disabled=True):
"""If the msgid is a numeric one, then register it to inform the user
it could furnish instead a symbolic msgid."""
try:
message_definitions = self.msgs_store.get_message_definitions(msgid)
for message_... | python | {
"resource": ""
} |
q269557 | MessagesHandlerMixIn.disable | test | def disable(self, msgid, scope="package", line=None, ignore_unknown=False):
"""don't output message of the given id"""
self._set_msg_status(
msgid, enable=False, scope=scope, line=line, ignore_unknown=ignore_unknown
)
self._register_by_id_managed_msg(msgid, line) | python | {
"resource": ""
} |
q269558 | MessagesHandlerMixIn.enable | test | def enable(self, msgid, scope="package", line=None, ignore_unknown=False):
"""reenable message of the given id"""
self._set_msg_status(
msgid, enable=True, scope=scope, line=line, ignore_unknown=ignore_unknown
)
self._register_by_id_managed_msg(msgid, line, is_disabled=False) | python | {
"resource": ""
} |
q269559 | MessagesHandlerMixIn._message_symbol | test | def _message_symbol(self, msgid):
"""Get the message symbol of the given message id
Return the original message id if the message does not
exist.
"""
try:
return [md.symbol for md in self.msgs_store.get_message_definitions(msgid)]
except UnknownMessageError:
... | python | {
"resource": ""
} |
q269560 | MessagesHandlerMixIn.is_message_enabled | test | def is_message_enabled(self, msg_descr, line=None, confidence=None):
"""return true if the message associated to the given message id is
enabled
msgid may be either a numeric or symbolic message id.
"""
if self.config.confidence and confidence:
if confidence.name not... | python | {
"resource": ""
} |
q269561 | MessagesHandlerMixIn.add_message | test | def add_message(
self,
msg_descr,
line=None,
node=None,
args=None,
confidence=UNDEFINED,
col_offset=None,
):
"""Adds a message given by ID or name.
If provided, the message string is expanded using args.
AST checkers must provide the ... | python | {
"resource": ""
} |
q269562 | MessagesHandlerMixIn.print_full_documentation | test | def print_full_documentation(self, stream=None):
"""output a full documentation in ReST format"""
if not stream:
stream = sys.stdout
print("Pylint global options and switches", file=stream)
print("----------------------------------", file=stream)
print("", file=strea... | python | {
"resource": ""
} |
q269563 | MessagesHandlerMixIn._print_checker_doc | test | def _print_checker_doc(checker_name, info, stream=None):
"""Helper method for print_full_documentation.
Also used by doc/exts/pylint_extensions.py.
"""
if not stream:
stream = sys.stdout
doc = info.get("doc")
module = info.get("module")
msgs = info.g... | python | {
"resource": ""
} |
q269564 | _get_indent_length | test | def _get_indent_length(line):
"""Return the length of the indentation on the given token's line."""
result = 0
for char in line:
if char == " ":
result += 1
elif char == "\t":
result += _TAB_LENGTH
else:
break
return result | python | {
"resource": ""
} |
q269565 | _get_indent_hint_line | test | def _get_indent_hint_line(bar_positions, bad_position):
"""Return a line with |s for each of the positions in the given lists."""
if not bar_positions:
return ("", "")
# TODO tabs should not be replaced by some random (8) number of spaces
bar_positions = [_get_indent_length(indent) for indent in... | python | {
"resource": ""
} |
q269566 | TokenWrapper.token_indent | test | def token_indent(self, idx):
"""Get an indentation string for hanging indentation, consisting of the line-indent plus
a number of spaces to fill up to the column of this token.
e.g. the token indent for foo
in "<TAB><TAB>print(foo)"
is "<TAB><TAB> "
"""
line... | python | {
"resource": ""
} |
q269567 | ContinuedLineState.handle_line_start | test | def handle_line_start(self, pos):
"""Record the first non-junk token at the start of a line."""
if self._line_start > -1:
return
check_token_position = pos
if self._tokens.token(pos) == _ASYNC_TOKEN:
check_token_position += 1
self._is_block_opener = (
... | python | {
"resource": ""
} |
q269568 | ContinuedLineState.get_valid_indentations | test | def get_valid_indentations(self, idx):
"""Returns the valid offsets for the token at the given position."""
# The closing brace on a dict or the 'for' in a dict comprehension may
# reset two indent levels because the dict value is ended implicitly
stack_top = -1
if (
... | python | {
"resource": ""
} |
q269569 | ContinuedLineState._hanging_indent_after_bracket | test | def _hanging_indent_after_bracket(self, bracket, position):
"""Extracts indentation information for a hanging indent
Case of hanging indent after a bracket (including parenthesis)
:param str bracket: bracket in question
:param int position: Position of bracket in self._tokens
... | python | {
"resource": ""
} |
q269570 | ContinuedLineState._continuation_inside_bracket | test | def _continuation_inside_bracket(self, bracket, position):
"""Extracts indentation information for a continued indent."""
indentation = self._tokens.line_indent(position)
token_indent = self._tokens.token_indent(position)
next_token_indent = self._tokens.token_indent(position + 1)
... | python | {
"resource": ""
} |
q269571 | ContinuedLineState.push_token | test | def push_token(self, token, position):
"""Pushes a new token for continued indentation on the stack.
Tokens that can modify continued indentation offsets are:
* opening brackets
* 'lambda'
* : inside dictionaries
push_token relies on the caller to filter out those... | python | {
"resource": ""
} |
q269572 | FormatChecker.new_line | test | def new_line(self, tokens, line_end, line_start):
"""a new line has been encountered, process it if necessary"""
if _last_token_on_line_is(tokens, line_end, ";"):
self.add_message("unnecessary-semicolon", line=tokens.start_line(line_end))
line_num = tokens.start_line(line_start)
... | python | {
"resource": ""
} |
q269573 | FormatChecker._check_keyword_parentheses | test | def _check_keyword_parentheses(self, tokens, start):
"""Check that there are not unnecessary parens after a keyword.
Parens are unnecessary if there is exactly one balanced outer pair on a
line, and it is followed by a colon, and contains no commas (i.e. is not a
tuple).
Args:
... | python | {
"resource": ""
} |
q269574 | FormatChecker._has_valid_type_annotation | test | def _has_valid_type_annotation(self, tokens, i):
"""Extended check of PEP-484 type hint presence"""
if not self._inside_brackets("("):
return False
# token_info
# type string start end line
# 0 1 2 3 4
bracket_level = 0
for token in tok... | python | {
"resource": ""
} |
q269575 | FormatChecker._check_equals_spacing | test | def _check_equals_spacing(self, tokens, i):
"""Check the spacing of a single equals sign."""
if self._has_valid_type_annotation(tokens, i):
self._check_space(tokens, i, (_MUST, _MUST))
elif self._inside_brackets("(") or self._inside_brackets("lambda"):
self._check_space(t... | python | {
"resource": ""
} |
q269576 | FormatChecker._check_surrounded_by_space | test | def _check_surrounded_by_space(self, tokens, i):
"""Check that a binary operator is surrounded by exactly one space."""
self._check_space(tokens, i, (_MUST, _MUST)) | python | {
"resource": ""
} |
q269577 | FormatChecker.visit_default | test | def visit_default(self, node):
"""check the node line number and check it if not yet done"""
if not node.is_statement:
return
if not node.root().pure_python:
return # XXX block visit of child nodes
prev_sibl = node.previous_sibling()
if prev_sibl is not N... | python | {
"resource": ""
} |
q269578 | FormatChecker._check_multi_statement_line | test | def _check_multi_statement_line(self, node, line):
"""Check for lines containing multiple statements."""
# Do not warn about multiple nested context managers
# in with statements.
if isinstance(node, nodes.With):
return
# For try... except... finally..., the two nodes... | python | {
"resource": ""
} |
q269579 | FormatChecker.check_lines | test | def check_lines(self, lines, i):
"""check lines have less than a maximum number of characters
"""
max_chars = self.config.max_line_length
ignore_long_line = self.config.ignore_long_lines
def check_line(line, i):
if not line.endswith("\n"):
self.add_me... | python | {
"resource": ""
} |
q269580 | FormatChecker.check_indent_level | test | def check_indent_level(self, string, expected, line_num):
"""return the indent level of the string
"""
indent = self.config.indent_string
if indent == "\\t": # \t is not interpreted in the configuration file
indent = "\t"
level = 0
unit_size = len(indent)
... | python | {
"resource": ""
} |
q269581 | _in_iterating_context | test | def _in_iterating_context(node):
"""Check if the node is being used as an iterator.
Definition is taken from lib2to3.fixer_util.in_special_context().
"""
parent = node.parent
# Since a call can't be the loop variant we only need to know if the node's
# parent is a 'for' loop to know it's being ... | python | {
"resource": ""
} |
q269582 | _is_conditional_import | test | def _is_conditional_import(node):
"""Checks if an import node is in the context of a conditional.
"""
parent = node.parent
return isinstance(
parent, (astroid.TryExcept, astroid.ExceptHandler, astroid.If, astroid.IfExp)
) | python | {
"resource": ""
} |
q269583 | Python3Checker.visit_name | test | def visit_name(self, node):
"""Detect when a "bad" built-in is referenced."""
found_node, _ = node.lookup(node.name)
if not _is_builtin(found_node):
return
if node.name not in self._bad_builtins:
return
if node_ignores_exception(node) or isinstance(
... | python | {
"resource": ""
} |
q269584 | Python3Checker.visit_subscript | test | def visit_subscript(self, node):
""" Look for indexing exceptions. """
try:
for inferred in node.value.infer():
if not isinstance(inferred, astroid.Instance):
continue
if utils.inherit_from_std_ex(inferred):
self.add_mes... | python | {
"resource": ""
} |
q269585 | Python3Checker.visit_attribute | test | def visit_attribute(self, node):
"""Look for removed attributes"""
if node.attrname == "xreadlines":
self.add_message("xreadlines-attribute", node=node)
return
exception_message = "message"
try:
for inferred in node.expr.infer():
if is... | python | {
"resource": ""
} |
q269586 | Python3Checker.visit_excepthandler | test | def visit_excepthandler(self, node):
"""Visit an except handler block and check for exception unpacking."""
def _is_used_in_except_block(node):
scope = node.scope()
current = node
while (
current
and current != scope
an... | python | {
"resource": ""
} |
q269587 | Python3Checker.visit_raise | test | def visit_raise(self, node):
"""Visit a raise statement and check for raising
strings or old-raise-syntax.
"""
# Ignore empty raise.
if node.exc is None:
return
expr = node.exc
if self._check_raise_value(node, expr):
return
try:
... | python | {
"resource": ""
} |
q269588 | find_pylintrc | test | def find_pylintrc():
"""search the pylint rc file and return its path if it find it, else None
"""
# is there a pylint rc file in the current directory ?
if os.path.exists("pylintrc"):
return os.path.abspath("pylintrc")
if os.path.exists(".pylintrc"):
return os.path.abspath(".pylintr... | python | {
"resource": ""
} |
q269589 | _validate | test | def _validate(value, optdict, name=""):
"""return a validated value for an option according to its type
optional argument name is only used for error message formatting
"""
try:
_type = optdict["type"]
except KeyError:
# FIXME
return value
return _call_validator(_type, o... | python | {
"resource": ""
} |
q269590 | _expand_default | test | def _expand_default(self, option):
"""Patch OptionParser.expand_default with custom behaviour
This will handle defaults to avoid overriding values in the
configuration file.
"""
if self.parser is None or not self.default_tag:
return option.help
optname = option._long_opts[0][2:]
try... | python | {
"resource": ""
} |
q269591 | OptionParser._match_long_opt | test | def _match_long_opt(self, opt):
"""Disable abbreviations."""
if opt not in self._long_opt:
raise optparse.BadOptionError(opt)
return opt | python | {
"resource": ""
} |
q269592 | OptionsManagerMixIn.register_options_provider | test | def register_options_provider(self, provider, own_group=True):
"""register an options provider"""
assert provider.priority <= 0, "provider's priority can't be >= 0"
for i in range(len(self.options_providers)):
if provider.priority > self.options_providers[i].priority:
... | python | {
"resource": ""
} |
q269593 | OptionsManagerMixIn.cb_set_provider_option | test | def cb_set_provider_option(self, option, opt, value, parser):
"""optik callback for option setting"""
if opt.startswith("--"):
# remove -- on long option
opt = opt[2:]
else:
# short option, get its long equivalent
opt = self._short_options[opt[1:]]... | python | {
"resource": ""
} |
q269594 | OptionsManagerMixIn.global_set_option | test | def global_set_option(self, opt, value):
"""set option on the correct option provider"""
self._all_options[opt].set_option(opt, value) | python | {
"resource": ""
} |
q269595 | OptionsManagerMixIn.generate_config | test | def generate_config(self, stream=None, skipsections=(), encoding=None):
"""write a configuration file according to the current configuration
into the given stream or stdout
"""
options_by_section = {}
sections = []
for provider in self.options_providers:
for s... | python | {
"resource": ""
} |
q269596 | OptionsManagerMixIn.load_config_file | test | def load_config_file(self):
"""dispatch values previously read from a configuration file to each
options provider)
"""
parser = self.cfgfile_parser
for section in parser.sections():
for option, value in parser.items(section):
try:
s... | python | {
"resource": ""
} |
q269597 | OptionsManagerMixIn.load_command_line_configuration | test | def load_command_line_configuration(self, args=None):
"""Override configuration according to command line parameters
return additional arguments
"""
with _patch_optparse():
if args is None:
args = sys.argv[1:]
else:
args = list(arg... | python | {
"resource": ""
} |
q269598 | OptionsManagerMixIn.add_help_section | test | def add_help_section(self, title, description, level=0):
"""add a dummy option section for help purpose """
group = optparse.OptionGroup(
self.cmdline_parser, title=title.capitalize(), description=description
)
group.level = level
self._maxlevel = max(self._maxlevel, ... | python | {
"resource": ""
} |
q269599 | OptionsManagerMixIn.help | test | def help(self, level=0):
"""return the usage string for available options """
self.cmdline_parser.formatter.output_level = level
with _patch_optparse():
return self.cmdline_parser.format_help() | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.