fname stringlengths 63 176 | rel_fname stringclasses 706 values | line int64 -1 4.5k | name stringlengths 1 81 | kind stringclasses 2 values | category stringclasses 2 values | info stringlengths 0 77.9k ⌀ |
|---|---|---|---|---|---|---|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,897 | _check_bases_classes | def | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,902 | is_abstract | def | function | def is_abstract(method):
return method.is_abstract(pass_is_abstract=_False)
# check if this class abstract
if class_is_abstract(node):
return
methods = sorted(
unimplemented_abstract_methods(node, is_abstract).items(),
key=lambda item: item[0],
)
for name, method in methods:
owner = method.parent.frame(future=_True)
if owner is node:
continue
# owner is not this class, it must be a parent class
# check that the ancestor's method is not abstract
if name in node.locals:
# it is redefined as an attribute or with a descriptor
continue
self.add_message("abstract-method", node=node, args=(name, owner.name))
def _check_init(self, node: nodes.FunctionDef, klass_node: nodes.ClassDef) -> None:
"""Check that the __init__ method call super or ancestors'__init__
method (unless it is used for type hinting with `typing.overload`)
"""
if not self.linter.is_message_enabled(
"super-init-not-called"
) and not self.linter.is_message_enabled("non-parent-init-called"):
return
to_call = _ancestors_to_call(klass_node)
not_called_yet = dict(to_call)
parents_with_called_inits: Set[bases.UnboundMethod] = set()
for stmt in node.nodes_of_class(nodes.Call):
expr = stmt.func
if not isinstance(expr, nodes.Attribute) or expr.attrname != "__init__":
continue
# skip the test if using super
if (
isinstance(expr.expr, nodes.Call)
and isinstance(expr.expr.func, nodes.Name)
and expr.expr.func.name == "super"
):
return
try:
for klass in expr.expr.infer():
if klass is astroid.Uninferable:
continue
# The inferred klass can be super(), which was
# assigned to a variable and the `__init__`
# was called later.
#
# base = super()
# base.__init__(...)
if (
isinstance(klass, astroid.Instance)
and isinstance(klass._proxied, nodes.ClassDef)
and is_builtin_object(klass._proxied)
and klass._proxied.name == "super"
):
return
if isinstance(klass, astroid.objects.Super):
return
try:
method = not_called_yet.pop(klass)
# Record that the class' init has been called
parents_with_called_inits.add(node_frame_class(method))
except KeyError:
if klass not in to_call:
self.add_message(
"non-parent-init-called", node=expr, args=klass.name
)
except astroid.InferenceError:
continue
for klass, method in not_called_yet.items():
# Check if the init of the class that defines this init has already
# been called.
if node_frame_class(method) in parents_with_called_inits:
return
# Return if klass is protocol
if klass.qname() in utils.TYPING_PROTOCOLS:
return
# Return if any of the klass' first-order bases is protocol
for base in klass.bases:
# We don't need to catch InferenceError here as _ancestors_to_call
# already does this for us.
for inf_base in base.infer():
if inf_base.qname() in utils.TYPING_PROTOCOLS:
return
if decorated_with(node, ["typing.overload"]):
continue
cls = node_frame_class(method)
if klass.name == "object" or (cls and cls.name == "object"):
continue
self.add_message(
"super-init-not-called",
args=klass.name,
node=node,
confidence=INFERENCE,
)
def _check_signature(self, method1, refmethod, class_type, cls):
"""Check that the signature of the two given methods match."""
if not (
isinstance(method1, nodes.FunctionDef)
and isinstance(refmethod, nodes.FunctionDef)
):
self.add_message(
"method-check-failed", args=(method1, refmethod), node=method1
)
return
instance = cls.instantiate_class()
method1 = astroid.scoped_nodes.function_to_method(method1, instance)
refmethod = astroid.scoped_nodes.function_to_method(refmethod, instance)
# Don't care about functions with unknown argument (builtins).
if method1.args.args is None or refmethod.args.args is None:
return
# Ignore private to class methods.
if is_attr_private(method1.name):
return
# Ignore setters, they have an implicit extra argument,
# which shouldn't be taken in consideration.
if is_property_setter(method1):
return
arg_differ_output = _different_parameters(
refmethod, method1, dummy_parameter_regex=self._dummy_rgx
)
if len(arg_differ_output) > 0:
for msg in arg_differ_output:
if "Number" in msg:
total_args_method1 = len(method1.args.args)
if method1.args.vararg:
total_args_method1 += 1
if method1.args.kwarg:
total_args_method1 += 1
if method1.args.kwonlyargs:
total_args_method1 += len(method1.args.kwonlyargs)
total_args_refmethod = len(refmethod.args.args)
if refmethod.args.vararg:
total_args_refmethod += 1
if refmethod.args.kwarg:
total_args_refmethod += 1
if refmethod.args.kwonlyargs:
total_args_refmethod += len(refmethod.args.kwonlyargs)
error_type = "arguments-differ"
msg_args = (
msg
+ f"was {total_args_refmethod} in '{refmethod.parent.frame().name}.{refmethod.name}' and "
f"is now {total_args_method1} in",
class_type,
f"{method1.parent.frame().name}.{method1.name}",
)
elif "renamed" in msg:
error_type = "arguments-renamed"
msg_args = (
msg,
class_type,
f"{method1.parent.frame().name}.{method1.name}",
)
else:
error_type = "arguments-differ"
msg_args = (
msg,
class_type,
f"{method1.parent.frame().name}.{method1.name}",
)
self.add_message(error_type, args=msg_args, node=method1)
elif (
len(method1.args.defaults) < len(refmethod.args.defaults)
and not method1.args.vararg
):
self.add_message(
"signature-differs", args=(class_type, method1.name), node=method1
)
def _uses_mandatory_method_param(self, node):
"""Check that attribute lookup name use first attribute variable name.
Name is `self` for method, `cls` for classmethod and `mcs` for metaclass.
"""
return self._is_mandatory_method_param(node.expr)
def _is_mandatory_method_param(self, node: nodes.NodeNG) -> bool:
"""Check if nodes.Name corresponds to first attribute variable name.
Name is `self` for method, `cls` for classmethod and `mcs` for metaclass.
"""
if self._first_attrs:
first_attr = self._first_attrs[-1]
else:
# It's possible the function was already unregistered.
closest_func = utils.get_node_first_ancestor_of_type(
node, nodes.FunctionDef
)
if closest_func is None:
return _False
if not closest_func.args.args:
return _False
first_attr = closest_func.args.args[0].name
return isinstance(node, nodes.Name) and node.name == first_attr
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,903 | is_abstract | ref | function | return method.is_abstract(pass_is_abstract=False)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,906 | class_is_abstract | ref | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,910 | unimplemented_abstract_methods | ref | function | unimplemented_abstract_methods(node, is_abstract).items(),
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,914 | frame | ref | function | owner = method.parent.frame(future=True)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,922 | add_message | ref | function | self.add_message("abstract-method", node=node, args=(name, owner.name))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,924 | _check_init | def | function | def _check_init(self, node: nodes.FunctionDef, klass_node: nodes.ClassDef) -> None:
"""Check that the __init__ method call super or ancestors'__init__
method (unless it is used for type hinting with `typing.overload`)
"""
if not self.linter.is_message_enabled(
"super-init-not-called"
) and not self.linter.is_message_enabled("non-parent-init-called"):
return
to_call = _ancestors_to_call(klass_node)
not_called_yet = dict(to_call)
parents_with_called_inits: Set[bases.UnboundMethod] = set()
for stmt in node.nodes_of_class(nodes.Call):
expr = stmt.func
if not isinstance(expr, nodes.Attribute) or expr.attrname != "__init__":
continue
# skip the test if using super
if (
isinstance(expr.expr, nodes.Call)
and isinstance(expr.expr.func, nodes.Name)
and expr.expr.func.name == "super"
):
return
try:
for klass in expr.expr.infer():
if klass is astroid.Uninferable:
continue
# The inferred klass can be super(), which was
# assigned to a variable and the `__init__`
# was called later.
#
# base = super()
# base.__init__(...)
if (
isinstance(klass, astroid.Instance)
and isinstance(klass._proxied, nodes.ClassDef)
and is_builtin_object(klass._proxied)
and klass._proxied.name == "super"
):
return
if isinstance(klass, astroid.objects.Super):
return
try:
method = not_called_yet.pop(klass)
# Record that the class' init has been called
parents_with_called_inits.add(node_frame_class(method))
except KeyError:
if klass not in to_call:
self.add_message(
"non-parent-init-called", node=expr, args=klass.name
)
except astroid.InferenceError:
continue
for klass, method in not_called_yet.items():
# Check if the init of the class that defines this init has already
# been called.
if node_frame_class(method) in parents_with_called_inits:
return
# Return if klass is protocol
if klass.qname() in utils.TYPING_PROTOCOLS:
return
# Return if any of the klass' first-order bases is protocol
for base in klass.bases:
# We don't need to catch InferenceError here as _ancestors_to_call
# already does this for us.
for inf_base in base.infer():
if inf_base.qname() in utils.TYPING_PROTOCOLS:
return
if decorated_with(node, ["typing.overload"]):
continue
cls = node_frame_class(method)
if klass.name == "object" or (cls and cls.name == "object"):
continue
self.add_message(
"super-init-not-called",
args=klass.name,
node=node,
confidence=INFERENCE,
)
def _check_signature(self, method1, refmethod, class_type, cls):
"""Check that the signature of the two given methods match."""
if not (
isinstance(method1, nodes.FunctionDef)
and isinstance(refmethod, nodes.FunctionDef)
):
self.add_message(
"method-check-failed", args=(method1, refmethod), node=method1
)
return
instance = cls.instantiate_class()
method1 = astroid.scoped_nodes.function_to_method(method1, instance)
refmethod = astroid.scoped_nodes.function_to_method(refmethod, instance)
# Don't care about functions with unknown argument (builtins).
if method1.args.args is None or refmethod.args.args is None:
return
# Ignore private to class methods.
if is_attr_private(method1.name):
return
# Ignore setters, they have an implicit extra argument,
# which shouldn't be taken in consideration.
if is_property_setter(method1):
return
arg_differ_output = _different_parameters(
refmethod, method1, dummy_parameter_regex=self._dummy_rgx
)
if len(arg_differ_output) > 0:
for msg in arg_differ_output:
if "Number" in msg:
total_args_method1 = len(method1.args.args)
if method1.args.vararg:
total_args_method1 += 1
if method1.args.kwarg:
total_args_method1 += 1
if method1.args.kwonlyargs:
total_args_method1 += len(method1.args.kwonlyargs)
total_args_refmethod = len(refmethod.args.args)
if refmethod.args.vararg:
total_args_refmethod += 1
if refmethod.args.kwarg:
total_args_refmethod += 1
if refmethod.args.kwonlyargs:
total_args_refmethod += len(refmethod.args.kwonlyargs)
error_type = "arguments-differ"
msg_args = (
msg
+ f"was {total_args_refmethod} in '{refmethod.parent.frame().name}.{refmethod.name}' and "
f"is now {total_args_method1} in",
class_type,
f"{method1.parent.frame().name}.{method1.name}",
)
elif "renamed" in msg:
error_type = "arguments-renamed"
msg_args = (
msg,
class_type,
f"{method1.parent.frame().name}.{method1.name}",
)
else:
error_type = "arguments-differ"
msg_args = (
msg,
class_type,
f"{method1.parent.frame().name}.{method1.name}",
)
self.add_message(error_type, args=msg_args, node=method1)
elif (
len(method1.args.defaults) < len(refmethod.args.defaults)
and not method1.args.vararg
):
self.add_message(
"signature-differs", args=(class_type, method1.name), node=method1
)
def _uses_mandatory_method_param(self, node):
"""Check that attribute lookup name use first attribute variable name.
Name is `self` for method, `cls` for classmethod and `mcs` for metaclass.
"""
return self._is_mandatory_method_param(node.expr)
def _is_mandatory_method_param(self, node: nodes.NodeNG) -> bool:
"""Check if nodes.Name corresponds to first attribute variable name.
Name is `self` for method, `cls` for classmethod and `mcs` for metaclass.
"""
if self._first_attrs:
first_attr = self._first_attrs[-1]
else:
# It's possible the function was already unregistered.
closest_func = utils.get_node_first_ancestor_of_type(
node, nodes.FunctionDef
)
if closest_func is None:
return _False
if not closest_func.args.args:
return _False
first_attr = closest_func.args.args[0].name
return isinstance(node, nodes.Name) and node.name == first_attr
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,928 | is_message_enabled | ref | function | if not self.linter.is_message_enabled(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,930 | is_message_enabled | ref | function | ) and not self.linter.is_message_enabled("non-parent-init-called"):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,932 | _ancestors_to_call | ref | function | to_call = _ancestors_to_call(klass_node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,935 | nodes_of_class | ref | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,947 | infer | ref | function | for klass in expr.expr.infer():
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,960 | is_builtin_object | ref | function | and is_builtin_object(klass._proxied)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,969 | node_frame_class | ref | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,972 | add_message | ref | function | self.add_message(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,980 | node_frame_class | ref | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,984 | qname | ref | function | if klass.qname() in utils.TYPING_PROTOCOLS:
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,991 | infer | ref | function | for inf_base in base.infer():
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,992 | qname | ref | function | if inf_base.qname() in utils.TYPING_PROTOCOLS:
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,995 | decorated_with | ref | function | if decorated_with(node, ["typing.overload"]):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 1,997 | node_frame_class | ref | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,000 | add_message | ref | function | self.add_message(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,007 | _check_signature | def | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,013 | add_message | ref | function | self.add_message(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,018 | instantiate_class | ref | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,019 | function_to_method | ref | function | method1 = astroid.scoped_nodes.function_to_method(method1, instance)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,020 | function_to_method | ref | function | refmethod = astroid.scoped_nodes.function_to_method(refmethod, instance)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,027 | is_attr_private | ref | function | if is_attr_private(method1.name):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,031 | is_property_setter | ref | function | if is_property_setter(method1):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,034 | _different_parameters | ref | function | arg_differ_output = _different_parameters(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,057 | frame | ref | function | + f"was {total_args_refmethod} in '{refmethod.parent.frame().name}.{refmethod.name}' and "
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,060 | frame | ref | function | f"{method1.parent.frame().name}.{method1.name}",
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,067 | frame | ref | function | f"{method1.parent.frame().name}.{method1.name}",
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,074 | frame | ref | function | f"{method1.parent.frame().name}.{method1.name}",
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,076 | add_message | ref | function | self.add_message(error_type, args=msg_args, node=method1)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,081 | add_message | ref | function | self.add_message(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,085 | _uses_mandatory_method_param | def | function | def _uses_mandatory_method_param(self, node):
"""Check that attribute lookup name use first attribute variable name.
Name is `self` for method, `cls` for classmethod and `mcs` for metaclass.
"""
return self._is_mandatory_method_param(node.expr)
def _is_mandatory_method_param(self, node: nodes.NodeNG) -> bool:
"""Check if nodes.Name corresponds to first attribute variable name.
Name is `self` for method, `cls` for classmethod and `mcs` for metaclass.
"""
if self._first_attrs:
first_attr = self._first_attrs[-1]
else:
# It's possible the function was already unregistered.
closest_func = utils.get_node_first_ancestor_of_type(
node, nodes.FunctionDef
)
if closest_func is None:
return _False
if not closest_func.args.args:
return _False
first_attr = closest_func.args.args[0].name
return isinstance(node, nodes.Name) and node.name == first_attr
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,090 | _is_mandatory_method_param | ref | function | return self._is_mandatory_method_param(node.expr)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,092 | _is_mandatory_method_param | def | function | def _is_mandatory_method_param(self, node: nodes.NodeNG) -> bool:
"""Check if nodes.Name corresponds to first attribute variable name.
Name is `self` for method, `cls` for classmethod and `mcs` for metaclass.
"""
if self._first_attrs:
first_attr = self._first_attrs[-1]
else:
# It's possible the function was already unregistered.
closest_func = utils.get_node_first_ancestor_of_type(
node, nodes.FunctionDef
)
if closest_func is None:
return _False
if not closest_func.args.args:
return _False
first_attr = closest_func.args.args[0].name
return isinstance(node, nodes.Name) and node.name == first_attr
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,101 | get_node_first_ancestor_of_type | ref | function | closest_func = utils.get_node_first_ancestor_of_type(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,112 | _ancestors_to_call | def | function | def _ancestors_to_call(
klass_node: nodes.ClassDef, method="__init__"
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,119 | ancestors | ref | function | for base_node in klass_node.ancestors(recurs=False):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/class_checker.py | pylint/checkers/classes/class_checker.py | 2,121 | igetattr | ref | function | to_call[base_node] = next(base_node.igetattr(method))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 22 | _safe_infer_call_result | def | function | def _safe_infer_call_result(node, caller, context=None):
"""Safely infer the return value of a function.
Returns None if inference failed or if there is some ambiguity (more than
one node has been inferred). Otherwise, returns inferred value.
"""
try:
inferit = node.infer_call_result(caller, context=context)
value = next(inferit)
except astroid.InferenceError:
return None # inference failed
except StopIteration:
return None # no values inferred
try:
next(inferit)
return None # there is ambiguity on the inferred node
except astroid.InferenceError:
return None # there is some kind of ambiguity
except StopIteration:
return value
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 29 | infer_call_result | ref | function | inferit = node.infer_call_result(caller, context=context)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 44 | SpecialMethodsChecker | def | class | __init__ visit_functiondef _check_unexpected_method_signature _is_wrapped_type _is_int _is_str _is_bool _is_bytes _is_tuple _is_dict _is_iterator _check_iter _check_len _check_bool _check_index _check_repr _check_str _check_bytes _check_hash _check_length_hint _check_format _check_getnewargs _check_getnewargs_ex |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 152 | check_messages | ref | function | @check_messages(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 167 | visit_functiondef | def | function | def visit_functiondef(self, node: nodes.FunctionDef) -> None:
if not node.is_method():
return
inferred = _safe_infer_call_result(node, node)
# Only want to check types that we are able to infer
if (
inferred
and node.name in self._protocol_map
and not is_function_body_ellipsis(node)
):
self._protocol_map[node.name](node, inferred)
if node.name in PYMETHODS:
self._check_unexpected_method_signature(node)
visit_asyncfunctiondef = visit_functiondef
def _check_unexpected_method_signature(self, node):
expected_params = SPECIAL_METHODS_PARAMS[node.name]
if expected_params is None:
# This can support a variable number of parameters.
return
if not node.args.args and not node.args.vararg:
# Method has no parameter, will be caught
# by no-method-argument.
return
if decorated_with(node, ["builtins.staticmethod"]):
# We expect to not take in consideration self.
all_args = node.args.args
else:
all_args = node.args.args[1:]
mandatory = len(all_args) - len(node.args.defaults)
optional = len(node.args.defaults)
current_params = mandatory + optional
if isinstance(expected_params, tuple):
# The expected number of parameters can be any value from this
# tuple, although the user should implement the method
# to take all of them in consideration.
emit = mandatory not in expected_params
# pylint: disable-next=consider-using-f-string
expected_params = "between %d or %d" % expected_params
else:
# If the number of mandatory parameters doesn't
# suffice, the expected parameters for this
# function will be deduced from the optional
# parameters.
rest = expected_params - mandatory
if rest == 0:
emit = _False
elif rest < 0:
emit = _True
elif rest > 0:
emit = not ((optional - rest) >= 0 or node.args.vararg)
if emit:
verb = "was" if current_params <= 1 else "were"
self.add_message(
"unexpected-special-method-signature",
args=(node.name, expected_params, current_params, verb),
node=node,
)
@staticmethod
def _is_wrapped_type(node, type_):
return (
isinstance(node, astroid.Instance)
and node.name == type_
and not isinstance(node, nodes.Const)
)
@staticmethod
def _is_int(node):
if SpecialMethodsChecker._is_wrapped_type(node, "int"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, int)
@staticmethod
def _is_str(node):
if SpecialMethodsChecker._is_wrapped_type(node, "str"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, str)
@staticmethod
def _is_bool(node):
if SpecialMethodsChecker._is_wrapped_type(node, "bool"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, bool)
@staticmethod
def _is_bytes(node):
if SpecialMethodsChecker._is_wrapped_type(node, "bytes"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, bytes)
@staticmethod
def _is_tuple(node):
if SpecialMethodsChecker._is_wrapped_type(node, "tuple"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, tuple)
@staticmethod
def _is_dict(node):
if SpecialMethodsChecker._is_wrapped_type(node, "dict"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, dict)
@staticmethod
def _is_iterator(node):
if node is astroid.Uninferable:
# Just ignore Uninferable objects.
return _True
if isinstance(node, astroid.bases.Generator):
# Generators can be iterated.
return _True
if isinstance(node, astroid.Instance):
try:
node.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
elif isinstance(node, nodes.ClassDef):
metaclass = node.metaclass()
if metaclass and isinstance(metaclass, nodes.ClassDef):
try:
metaclass.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
return _False
def _check_iter(self, node, inferred):
if not self._is_iterator(inferred):
self.add_message("non-iterator-returned", node=node)
def _check_len(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-returned", node=node)
def _check_bool(self, node, inferred):
if not self._is_bool(inferred):
self.add_message("invalid-bool-returned", node=node)
def _check_index(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-index-returned", node=node)
def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 168 | is_method | ref | function | if not node.is_method():
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 171 | _safe_infer_call_result | ref | function | inferred = _safe_infer_call_result(node, node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 176 | is_function_body_ellipsis | ref | function | and not is_function_body_ellipsis(node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 181 | _check_unexpected_method_signature | ref | function | self._check_unexpected_method_signature(node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 185 | _check_unexpected_method_signature | def | function | def _check_unexpected_method_signature(self, node):
expected_params = SPECIAL_METHODS_PARAMS[node.name]
if expected_params is None:
# This can support a variable number of parameters.
return
if not node.args.args and not node.args.vararg:
# Method has no parameter, will be caught
# by no-method-argument.
return
if decorated_with(node, ["builtins.staticmethod"]):
# We expect to not take in consideration self.
all_args = node.args.args
else:
all_args = node.args.args[1:]
mandatory = len(all_args) - len(node.args.defaults)
optional = len(node.args.defaults)
current_params = mandatory + optional
if isinstance(expected_params, tuple):
# The expected number of parameters can be any value from this
# tuple, although the user should implement the method
# to take all of them in consideration.
emit = mandatory not in expected_params
# pylint: disable-next=consider-using-f-string
expected_params = "between %d or %d" % expected_params
else:
# If the number of mandatory parameters doesn't
# suffice, the expected parameters for this
# function will be deduced from the optional
# parameters.
rest = expected_params - mandatory
if rest == 0:
emit = _False
elif rest < 0:
emit = _True
elif rest > 0:
emit = not ((optional - rest) >= 0 or node.args.vararg)
if emit:
verb = "was" if current_params <= 1 else "were"
self.add_message(
"unexpected-special-method-signature",
args=(node.name, expected_params, current_params, verb),
node=node,
)
@staticmethod
def _is_wrapped_type(node, type_):
return (
isinstance(node, astroid.Instance)
and node.name == type_
and not isinstance(node, nodes.Const)
)
@staticmethod
def _is_int(node):
if SpecialMethodsChecker._is_wrapped_type(node, "int"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, int)
@staticmethod
def _is_str(node):
if SpecialMethodsChecker._is_wrapped_type(node, "str"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, str)
@staticmethod
def _is_bool(node):
if SpecialMethodsChecker._is_wrapped_type(node, "bool"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, bool)
@staticmethod
def _is_bytes(node):
if SpecialMethodsChecker._is_wrapped_type(node, "bytes"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, bytes)
@staticmethod
def _is_tuple(node):
if SpecialMethodsChecker._is_wrapped_type(node, "tuple"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, tuple)
@staticmethod
def _is_dict(node):
if SpecialMethodsChecker._is_wrapped_type(node, "dict"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, dict)
@staticmethod
def _is_iterator(node):
if node is astroid.Uninferable:
# Just ignore Uninferable objects.
return _True
if isinstance(node, astroid.bases.Generator):
# Generators can be iterated.
return _True
if isinstance(node, astroid.Instance):
try:
node.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
elif isinstance(node, nodes.ClassDef):
metaclass = node.metaclass()
if metaclass and isinstance(metaclass, nodes.ClassDef):
try:
metaclass.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
return _False
def _check_iter(self, node, inferred):
if not self._is_iterator(inferred):
self.add_message("non-iterator-returned", node=node)
def _check_len(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-returned", node=node)
def _check_bool(self, node, inferred):
if not self._is_bool(inferred):
self.add_message("invalid-bool-returned", node=node)
def _check_index(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-index-returned", node=node)
def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 196 | decorated_with | ref | function | if decorated_with(node, ["builtins.staticmethod"]):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 227 | add_message | ref | function | self.add_message(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 234 | _is_wrapped_type | def | function | def _is_wrapped_type(node, type_):
return (
isinstance(node, astroid.Instance)
and node.name == type_
and not isinstance(node, nodes.Const)
)
@staticmethod
def _is_int(node):
if SpecialMethodsChecker._is_wrapped_type(node, "int"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, int)
@staticmethod
def _is_str(node):
if SpecialMethodsChecker._is_wrapped_type(node, "str"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, str)
@staticmethod
def _is_bool(node):
if SpecialMethodsChecker._is_wrapped_type(node, "bool"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, bool)
@staticmethod
def _is_bytes(node):
if SpecialMethodsChecker._is_wrapped_type(node, "bytes"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, bytes)
@staticmethod
def _is_tuple(node):
if SpecialMethodsChecker._is_wrapped_type(node, "tuple"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, tuple)
@staticmethod
def _is_dict(node):
if SpecialMethodsChecker._is_wrapped_type(node, "dict"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, dict)
@staticmethod
def _is_iterator(node):
if node is astroid.Uninferable:
# Just ignore Uninferable objects.
return _True
if isinstance(node, astroid.bases.Generator):
# Generators can be iterated.
return _True
if isinstance(node, astroid.Instance):
try:
node.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
elif isinstance(node, nodes.ClassDef):
metaclass = node.metaclass()
if metaclass and isinstance(metaclass, nodes.ClassDef):
try:
metaclass.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
return _False
def _check_iter(self, node, inferred):
if not self._is_iterator(inferred):
self.add_message("non-iterator-returned", node=node)
def _check_len(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-returned", node=node)
def _check_bool(self, node, inferred):
if not self._is_bool(inferred):
self.add_message("invalid-bool-returned", node=node)
def _check_index(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-index-returned", node=node)
def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 242 | _is_int | def | function | def _is_int(node):
if SpecialMethodsChecker._is_wrapped_type(node, "int"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, int)
@staticmethod
def _is_str(node):
if SpecialMethodsChecker._is_wrapped_type(node, "str"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, str)
@staticmethod
def _is_bool(node):
if SpecialMethodsChecker._is_wrapped_type(node, "bool"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, bool)
@staticmethod
def _is_bytes(node):
if SpecialMethodsChecker._is_wrapped_type(node, "bytes"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, bytes)
@staticmethod
def _is_tuple(node):
if SpecialMethodsChecker._is_wrapped_type(node, "tuple"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, tuple)
@staticmethod
def _is_dict(node):
if SpecialMethodsChecker._is_wrapped_type(node, "dict"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, dict)
@staticmethod
def _is_iterator(node):
if node is astroid.Uninferable:
# Just ignore Uninferable objects.
return _True
if isinstance(node, astroid.bases.Generator):
# Generators can be iterated.
return _True
if isinstance(node, astroid.Instance):
try:
node.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
elif isinstance(node, nodes.ClassDef):
metaclass = node.metaclass()
if metaclass and isinstance(metaclass, nodes.ClassDef):
try:
metaclass.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
return _False
def _check_iter(self, node, inferred):
if not self._is_iterator(inferred):
self.add_message("non-iterator-returned", node=node)
def _check_len(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-returned", node=node)
def _check_bool(self, node, inferred):
if not self._is_bool(inferred):
self.add_message("invalid-bool-returned", node=node)
def _check_index(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-index-returned", node=node)
def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 243 | _is_wrapped_type | ref | function | if SpecialMethodsChecker._is_wrapped_type(node, "int"):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 249 | _is_str | def | function | def _is_str(node):
if SpecialMethodsChecker._is_wrapped_type(node, "str"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, str)
@staticmethod
def _is_bool(node):
if SpecialMethodsChecker._is_wrapped_type(node, "bool"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, bool)
@staticmethod
def _is_bytes(node):
if SpecialMethodsChecker._is_wrapped_type(node, "bytes"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, bytes)
@staticmethod
def _is_tuple(node):
if SpecialMethodsChecker._is_wrapped_type(node, "tuple"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, tuple)
@staticmethod
def _is_dict(node):
if SpecialMethodsChecker._is_wrapped_type(node, "dict"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, dict)
@staticmethod
def _is_iterator(node):
if node is astroid.Uninferable:
# Just ignore Uninferable objects.
return _True
if isinstance(node, astroid.bases.Generator):
# Generators can be iterated.
return _True
if isinstance(node, astroid.Instance):
try:
node.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
elif isinstance(node, nodes.ClassDef):
metaclass = node.metaclass()
if metaclass and isinstance(metaclass, nodes.ClassDef):
try:
metaclass.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
return _False
def _check_iter(self, node, inferred):
if not self._is_iterator(inferred):
self.add_message("non-iterator-returned", node=node)
def _check_len(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-returned", node=node)
def _check_bool(self, node, inferred):
if not self._is_bool(inferred):
self.add_message("invalid-bool-returned", node=node)
def _check_index(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-index-returned", node=node)
def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 250 | _is_wrapped_type | ref | function | if SpecialMethodsChecker._is_wrapped_type(node, "str"):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 256 | _is_bool | def | function | def _is_bool(node):
if SpecialMethodsChecker._is_wrapped_type(node, "bool"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, bool)
@staticmethod
def _is_bytes(node):
if SpecialMethodsChecker._is_wrapped_type(node, "bytes"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, bytes)
@staticmethod
def _is_tuple(node):
if SpecialMethodsChecker._is_wrapped_type(node, "tuple"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, tuple)
@staticmethod
def _is_dict(node):
if SpecialMethodsChecker._is_wrapped_type(node, "dict"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, dict)
@staticmethod
def _is_iterator(node):
if node is astroid.Uninferable:
# Just ignore Uninferable objects.
return _True
if isinstance(node, astroid.bases.Generator):
# Generators can be iterated.
return _True
if isinstance(node, astroid.Instance):
try:
node.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
elif isinstance(node, nodes.ClassDef):
metaclass = node.metaclass()
if metaclass and isinstance(metaclass, nodes.ClassDef):
try:
metaclass.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
return _False
def _check_iter(self, node, inferred):
if not self._is_iterator(inferred):
self.add_message("non-iterator-returned", node=node)
def _check_len(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-returned", node=node)
def _check_bool(self, node, inferred):
if not self._is_bool(inferred):
self.add_message("invalid-bool-returned", node=node)
def _check_index(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-index-returned", node=node)
def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 257 | _is_wrapped_type | ref | function | if SpecialMethodsChecker._is_wrapped_type(node, "bool"):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 263 | _is_bytes | def | function | def _is_bytes(node):
if SpecialMethodsChecker._is_wrapped_type(node, "bytes"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, bytes)
@staticmethod
def _is_tuple(node):
if SpecialMethodsChecker._is_wrapped_type(node, "tuple"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, tuple)
@staticmethod
def _is_dict(node):
if SpecialMethodsChecker._is_wrapped_type(node, "dict"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, dict)
@staticmethod
def _is_iterator(node):
if node is astroid.Uninferable:
# Just ignore Uninferable objects.
return _True
if isinstance(node, astroid.bases.Generator):
# Generators can be iterated.
return _True
if isinstance(node, astroid.Instance):
try:
node.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
elif isinstance(node, nodes.ClassDef):
metaclass = node.metaclass()
if metaclass and isinstance(metaclass, nodes.ClassDef):
try:
metaclass.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
return _False
def _check_iter(self, node, inferred):
if not self._is_iterator(inferred):
self.add_message("non-iterator-returned", node=node)
def _check_len(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-returned", node=node)
def _check_bool(self, node, inferred):
if not self._is_bool(inferred):
self.add_message("invalid-bool-returned", node=node)
def _check_index(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-index-returned", node=node)
def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 264 | _is_wrapped_type | ref | function | if SpecialMethodsChecker._is_wrapped_type(node, "bytes"):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 270 | _is_tuple | def | function | def _is_tuple(node):
if SpecialMethodsChecker._is_wrapped_type(node, "tuple"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, tuple)
@staticmethod
def _is_dict(node):
if SpecialMethodsChecker._is_wrapped_type(node, "dict"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, dict)
@staticmethod
def _is_iterator(node):
if node is astroid.Uninferable:
# Just ignore Uninferable objects.
return _True
if isinstance(node, astroid.bases.Generator):
# Generators can be iterated.
return _True
if isinstance(node, astroid.Instance):
try:
node.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
elif isinstance(node, nodes.ClassDef):
metaclass = node.metaclass()
if metaclass and isinstance(metaclass, nodes.ClassDef):
try:
metaclass.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
return _False
def _check_iter(self, node, inferred):
if not self._is_iterator(inferred):
self.add_message("non-iterator-returned", node=node)
def _check_len(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-returned", node=node)
def _check_bool(self, node, inferred):
if not self._is_bool(inferred):
self.add_message("invalid-bool-returned", node=node)
def _check_index(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-index-returned", node=node)
def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 271 | _is_wrapped_type | ref | function | if SpecialMethodsChecker._is_wrapped_type(node, "tuple"):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 277 | _is_dict | def | function | def _is_dict(node):
if SpecialMethodsChecker._is_wrapped_type(node, "dict"):
return _True
return isinstance(node, nodes.Const) and isinstance(node.value, dict)
@staticmethod
def _is_iterator(node):
if node is astroid.Uninferable:
# Just ignore Uninferable objects.
return _True
if isinstance(node, astroid.bases.Generator):
# Generators can be iterated.
return _True
if isinstance(node, astroid.Instance):
try:
node.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
elif isinstance(node, nodes.ClassDef):
metaclass = node.metaclass()
if metaclass and isinstance(metaclass, nodes.ClassDef):
try:
metaclass.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
return _False
def _check_iter(self, node, inferred):
if not self._is_iterator(inferred):
self.add_message("non-iterator-returned", node=node)
def _check_len(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-returned", node=node)
def _check_bool(self, node, inferred):
if not self._is_bool(inferred):
self.add_message("invalid-bool-returned", node=node)
def _check_index(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-index-returned", node=node)
def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 278 | _is_wrapped_type | ref | function | if SpecialMethodsChecker._is_wrapped_type(node, "dict"):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 284 | _is_iterator | def | function | def _is_iterator(node):
if node is astroid.Uninferable:
# Just ignore Uninferable objects.
return _True
if isinstance(node, astroid.bases.Generator):
# Generators can be iterated.
return _True
if isinstance(node, astroid.Instance):
try:
node.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
elif isinstance(node, nodes.ClassDef):
metaclass = node.metaclass()
if metaclass and isinstance(metaclass, nodes.ClassDef):
try:
metaclass.local_attr(NEXT_METHOD)
return _True
except astroid.NotFoundError:
pass
return _False
def _check_iter(self, node, inferred):
if not self._is_iterator(inferred):
self.add_message("non-iterator-returned", node=node)
def _check_len(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-returned", node=node)
def _check_bool(self, node, inferred):
if not self._is_bool(inferred):
self.add_message("invalid-bool-returned", node=node)
def _check_index(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-index-returned", node=node)
def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 294 | local_attr | ref | function | node.local_attr(NEXT_METHOD)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 299 | metaclass | ref | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 302 | local_attr | ref | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 308 | _check_iter | def | function | def _check_iter(self, node, inferred):
if not self._is_iterator(inferred):
self.add_message("non-iterator-returned", node=node)
def _check_len(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-returned", node=node)
def _check_bool(self, node, inferred):
if not self._is_bool(inferred):
self.add_message("invalid-bool-returned", node=node)
def _check_index(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-index-returned", node=node)
def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 309 | _is_iterator | ref | function | if not self._is_iterator(inferred):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 310 | add_message | ref | function | self.add_message("non-iterator-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 312 | _check_len | def | function | def _check_len(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-returned", node=node)
def _check_bool(self, node, inferred):
if not self._is_bool(inferred):
self.add_message("invalid-bool-returned", node=node)
def _check_index(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-index-returned", node=node)
def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 313 | _is_int | ref | function | if not self._is_int(inferred):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 314 | add_message | ref | function | self.add_message("invalid-length-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 316 | add_message | ref | function | self.add_message("invalid-length-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 318 | _check_bool | def | function | def _check_bool(self, node, inferred):
if not self._is_bool(inferred):
self.add_message("invalid-bool-returned", node=node)
def _check_index(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-index-returned", node=node)
def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 319 | _is_bool | ref | function | if not self._is_bool(inferred):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 320 | add_message | ref | function | self.add_message("invalid-bool-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 322 | _check_index | def | function | def _check_index(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-index-returned", node=node)
def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 323 | _is_int | ref | function | if not self._is_int(inferred):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 324 | add_message | ref | function | self.add_message("invalid-index-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 326 | _check_repr | def | function | def _check_repr(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-repr-returned", node=node)
def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 327 | _is_str | ref | function | if not self._is_str(inferred):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 328 | add_message | ref | function | self.add_message("invalid-repr-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 330 | _check_str | def | function | def _check_str(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-str-returned", node=node)
def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 331 | _is_str | ref | function | if not self._is_str(inferred):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 332 | add_message | ref | function | self.add_message("invalid-str-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 334 | _check_bytes | def | function | def _check_bytes(self, node, inferred):
if not self._is_bytes(inferred):
self.add_message("invalid-bytes-returned", node=node)
def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 335 | _is_bytes | ref | function | if not self._is_bytes(inferred):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 336 | add_message | ref | function | self.add_message("invalid-bytes-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 338 | _check_hash | def | function | def _check_hash(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-hash-returned", node=node)
def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 339 | _is_int | ref | function | if not self._is_int(inferred):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 340 | add_message | ref | function | self.add_message("invalid-hash-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 342 | _check_length_hint | def | function | def _check_length_hint(self, node, inferred):
if not self._is_int(inferred):
self.add_message("invalid-length-hint-returned", node=node)
elif isinstance(inferred, nodes.Const) and inferred.value < 0:
self.add_message("invalid-length-hint-returned", node=node)
def _check_format(self, node, inferred):
if not self._is_str(inferred):
self.add_message("invalid-format-returned", node=node)
def _check_getnewargs(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-returned", node=node)
def _check_getnewargs_ex(self, node, inferred):
if not self._is_tuple(inferred):
self.add_message("invalid-getnewargs-ex-returned", node=node)
return
if not isinstance(inferred, nodes.Tuple):
# If it's not an astroid.Tuple we can't analyze it further
return
found_error = _False
if len(inferred.elts) != 2:
found_error = _True
else:
for arg, check in (
(inferred.elts[0], self._is_tuple),
(inferred.elts[1], self._is_dict),
):
if isinstance(arg, nodes.Call):
arg = safe_infer(arg)
if arg and arg is not astroid.Uninferable:
if not check(arg):
found_error = _True
break
if found_error:
self.add_message("invalid-getnewargs-ex-returned", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/classes/special_methods_checker.py | pylint/checkers/classes/special_methods_checker.py | 343 | _is_int | ref | function | if not self._is_int(inferred):
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.