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/stdlib.py | pylint/checkers/stdlib.py | 507 | inferred | ref | function | inferred_args = arg.inferred()
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 511 | qname | ref | function | if inferred.qname() == OS_ENVIRON:
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 512 | add_message | ref | function | self.add_message("shallow-copy-environ", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 515 | check_messages | ref | function | @utils.check_messages(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 530 | visit_call | def | function | def visit_call(self, node: nodes.Call) -> None:
"""Visit a Call node."""
self.check_deprecated_class_in_call(node)
for inferred in utils.infer_all(node.func):
if inferred is astroid.Uninferable:
continue
if inferred.root().name in OPEN_MODULE:
if (
isinstance(node.func, nodes.Name)
and node.func.name in OPEN_FILES_MODE
):
self._check_open_mode(node)
if (
isinstance(node.func, nodes.Name)
and node.func.name in OPEN_FILES_ENCODING
or isinstance(node.func, nodes.Attribute)
and node.func.attrname in OPEN_FILES_ENCODING
):
self._check_open_encoded(node, inferred.root().name)
elif inferred.root().name == UNITTEST_CASE:
self._check_redundant_assert(node, inferred)
elif isinstance(inferred, nodes.ClassDef):
if inferred.qname() == THREADING_THREAD:
self._check_bad_thread_instantiation(node)
elif inferred.qname() == SUBPROCESS_POPEN:
self._check_for_preexec_fn_in_popen(node)
elif isinstance(inferred, nodes.FunctionDef):
name = inferred.qname()
if name == COPY_COPY:
self._check_shallow_copy_environ(node)
elif name in ENV_GETTERS:
self._check_env_function(node, inferred)
elif name == SUBPROCESS_RUN:
self._check_for_check_kw_in_run(node)
elif name in DEBUG_BREAKPOINTS:
self.add_message("forgotten-debug-statement", node=node)
self.check_deprecated_method(node, inferred)
@utils.check_messages("boolean-datetime")
def visit_unaryop(self, node: nodes.UnaryOp) -> None:
if node.op == "not":
self._check_datetime(node.operand)
@utils.check_messages("boolean-datetime")
def visit_if(self, node: nodes.If) -> None:
self._check_datetime(node.test)
@utils.check_messages("boolean-datetime")
def visit_ifexp(self, node: nodes.IfExp) -> None:
self._check_datetime(node.test)
@utils.check_messages("boolean-datetime")
def visit_boolop(self, node: nodes.BoolOp) -> None:
for value in node.values:
self._check_datetime(value)
@utils.check_messages("lru-cache-decorating-method")
def visit_functiondef(self, node: nodes.FunctionDef) -> None:
if node.decorators and isinstance(node.parent, nodes.ClassDef):
self._check_lru_cache_decorators(node.decorators)
def _check_lru_cache_decorators(self, decorators: nodes.Decorators) -> None:
"""Check if instance methods are decorated with functools.lru_cache."""
lru_cache_nodes: List[nodes.NodeNG] = []
for d_node in decorators.nodes:
try:
for infered_node in d_node.infer():
q_name = infered_node.qname()
if q_name in NON_INSTANCE_METHODS:
return
if q_name not in LRU_CACHE:
return
# Check if there is a maxsize argument to the call
if isinstance(d_node, nodes.Call):
try:
utils.get_argument_from_call(
d_node, position=0, keyword="maxsize"
)
return
except utils.NoSuchArgumentError:
pass
lru_cache_nodes.append(d_node)
break
except astroid.InferenceError:
pass
for lru_cache_node in lru_cache_nodes:
self.add_message(
"lru-cache-decorating-method",
node=lru_cache_node,
confidence=interfaces.INFERENCE,
)
def _check_redundant_assert(self, node, infer):
if (
isinstance(infer, astroid.BoundMethod)
and node.args
and isinstance(node.args[0], nodes.Const)
and infer.name in {"assert_True", "assert_False"}
):
self.add_message(
"redundant-unittest-assert",
args=(infer.name, node.args[0].value),
node=node,
)
def _check_datetime(self, node):
"""Check that a datetime was inferred.
If so, emit boolean-datetime warning.
"""
try:
inferred = next(node.infer())
except astroid.InferenceError:
return
if (
isinstance(inferred, astroid.Instance)
and inferred.qname() == "datetime.time"
):
self.add_message("boolean-datetime", node=node)
def _check_open_mode(self, node):
"""Check that the mode argument of an open or file call is valid."""
try:
mode_arg = utils.get_argument_from_call(node, position=1, keyword="mode")
except utils.NoSuchArgumentError:
return
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if isinstance(mode_arg, nodes.Const) and not _check_mode_str(
mode_arg.value
):
self.add_message(
"bad-open-mode",
node=node,
args=mode_arg.value or str(mode_arg.value),
)
def _check_open_encoded(self, node: nodes.Call, open_module: str) -> None:
"""Check that the encoded argument of an open call is valid."""
mode_arg = None
try:
if open_module == "_io":
mode_arg = utils.get_argument_from_call(
node, position=1, keyword="mode"
)
elif open_module == "pathlib":
mode_arg = utils.get_argument_from_call(
node, position=0, keyword="mode"
)
except utils.NoSuchArgumentError:
pass
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if (
not mode_arg
or isinstance(mode_arg, nodes.Const)
and (not mode_arg.value or "b" not in mode_arg.value)
):
encoding_arg = None
try:
if open_module == "pathlib":
if node.func.attrname == "read_text":
encoding_arg = utils.get_argument_from_call(
node, position=0, keyword="encoding"
)
elif node.func.attrname == "write_text":
encoding_arg = utils.get_argument_from_call(
node, position=1, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=2, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=3, keyword="encoding"
)
except utils.NoSuchArgumentError:
self.add_message("unspecified-encoding", node=node)
if encoding_arg:
encoding_arg = utils.safe_infer(encoding_arg)
if isinstance(encoding_arg, nodes.Const) and encoding_arg.value is None:
self.add_message("unspecified-encoding", node=node)
def _check_env_function(self, node, infer):
env_name_kwarg = "key"
env_value_kwarg = "default"
if node.keywords:
kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
else:
kwargs = None
if node.args:
env_name_arg = node.args[0]
elif kwargs and env_name_kwarg in kwargs:
env_name_arg = kwargs[env_name_kwarg]
else:
env_name_arg = None
if env_name_arg:
self._check_invalid_envvar_value(
node=node,
message="invalid-envvar-value",
call_arg=utils.safe_infer(env_name_arg),
infer=infer,
allow_none=_False,
)
if len(node.args) == 2:
env_value_arg = node.args[1]
elif kwargs and env_value_kwarg in kwargs:
env_value_arg = kwargs[env_value_kwarg]
else:
env_value_arg = None
if env_value_arg:
self._check_invalid_envvar_value(
node=node,
infer=infer,
message="invalid-envvar-default",
call_arg=utils.safe_infer(env_value_arg),
allow_none=_True,
)
def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
if call_arg in (astroid.Uninferable, None):
return
name = infer.qname()
if isinstance(call_arg, nodes.Const):
emit = _False
if call_arg.value is None:
emit = not allow_none
elif not isinstance(call_arg.value, str):
emit = _True
if emit:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
else:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
def deprecated_modules(self):
"""Callback returning the deprecated modules."""
return self._deprecated_modules
def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 532 | check_deprecated_class_in_call | ref | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 533 | infer_all | ref | function | for inferred in utils.infer_all(node.func):
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 536 | root | ref | function | if inferred.root().name in OPEN_MODULE:
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 541 | _check_open_mode | ref | function | self._check_open_mode(node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 548 | _check_open_encoded | ref | function | self._check_open_encoded(node, inferred.root().name)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 548 | root | ref | function | self._check_open_encoded(node, inferred.root().name)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 549 | root | ref | function | elif inferred.root().name == UNITTEST_CASE:
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 550 | _check_redundant_assert | ref | function | self._check_redundant_assert(node, inferred)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 552 | qname | ref | function | if inferred.qname() == THREADING_THREAD:
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 553 | _check_bad_thread_instantiation | ref | function | self._check_bad_thread_instantiation(node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 554 | qname | ref | function | elif inferred.qname() == SUBPROCESS_POPEN:
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 555 | _check_for_preexec_fn_in_popen | ref | function | self._check_for_preexec_fn_in_popen(node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 557 | qname | ref | function | name = inferred.qname()
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 559 | _check_shallow_copy_environ | ref | function | self._check_shallow_copy_environ(node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 561 | _check_env_function | ref | function | self._check_env_function(node, inferred)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 563 | _check_for_check_kw_in_run | ref | function | self._check_for_check_kw_in_run(node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 565 | add_message | ref | function | self.add_message("forgotten-debug-statement", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 566 | check_deprecated_method | ref | function | self.check_deprecated_method(node, inferred)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 568 | check_messages | ref | function | @utils.check_messages("boolean-datetime")
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 569 | visit_unaryop | def | function | def visit_unaryop(self, node: nodes.UnaryOp) -> None:
if node.op == "not":
self._check_datetime(node.operand)
@utils.check_messages("boolean-datetime")
def visit_if(self, node: nodes.If) -> None:
self._check_datetime(node.test)
@utils.check_messages("boolean-datetime")
def visit_ifexp(self, node: nodes.IfExp) -> None:
self._check_datetime(node.test)
@utils.check_messages("boolean-datetime")
def visit_boolop(self, node: nodes.BoolOp) -> None:
for value in node.values:
self._check_datetime(value)
@utils.check_messages("lru-cache-decorating-method")
def visit_functiondef(self, node: nodes.FunctionDef) -> None:
if node.decorators and isinstance(node.parent, nodes.ClassDef):
self._check_lru_cache_decorators(node.decorators)
def _check_lru_cache_decorators(self, decorators: nodes.Decorators) -> None:
"""Check if instance methods are decorated with functools.lru_cache."""
lru_cache_nodes: List[nodes.NodeNG] = []
for d_node in decorators.nodes:
try:
for infered_node in d_node.infer():
q_name = infered_node.qname()
if q_name in NON_INSTANCE_METHODS:
return
if q_name not in LRU_CACHE:
return
# Check if there is a maxsize argument to the call
if isinstance(d_node, nodes.Call):
try:
utils.get_argument_from_call(
d_node, position=0, keyword="maxsize"
)
return
except utils.NoSuchArgumentError:
pass
lru_cache_nodes.append(d_node)
break
except astroid.InferenceError:
pass
for lru_cache_node in lru_cache_nodes:
self.add_message(
"lru-cache-decorating-method",
node=lru_cache_node,
confidence=interfaces.INFERENCE,
)
def _check_redundant_assert(self, node, infer):
if (
isinstance(infer, astroid.BoundMethod)
and node.args
and isinstance(node.args[0], nodes.Const)
and infer.name in {"assert_True", "assert_False"}
):
self.add_message(
"redundant-unittest-assert",
args=(infer.name, node.args[0].value),
node=node,
)
def _check_datetime(self, node):
"""Check that a datetime was inferred.
If so, emit boolean-datetime warning.
"""
try:
inferred = next(node.infer())
except astroid.InferenceError:
return
if (
isinstance(inferred, astroid.Instance)
and inferred.qname() == "datetime.time"
):
self.add_message("boolean-datetime", node=node)
def _check_open_mode(self, node):
"""Check that the mode argument of an open or file call is valid."""
try:
mode_arg = utils.get_argument_from_call(node, position=1, keyword="mode")
except utils.NoSuchArgumentError:
return
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if isinstance(mode_arg, nodes.Const) and not _check_mode_str(
mode_arg.value
):
self.add_message(
"bad-open-mode",
node=node,
args=mode_arg.value or str(mode_arg.value),
)
def _check_open_encoded(self, node: nodes.Call, open_module: str) -> None:
"""Check that the encoded argument of an open call is valid."""
mode_arg = None
try:
if open_module == "_io":
mode_arg = utils.get_argument_from_call(
node, position=1, keyword="mode"
)
elif open_module == "pathlib":
mode_arg = utils.get_argument_from_call(
node, position=0, keyword="mode"
)
except utils.NoSuchArgumentError:
pass
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if (
not mode_arg
or isinstance(mode_arg, nodes.Const)
and (not mode_arg.value or "b" not in mode_arg.value)
):
encoding_arg = None
try:
if open_module == "pathlib":
if node.func.attrname == "read_text":
encoding_arg = utils.get_argument_from_call(
node, position=0, keyword="encoding"
)
elif node.func.attrname == "write_text":
encoding_arg = utils.get_argument_from_call(
node, position=1, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=2, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=3, keyword="encoding"
)
except utils.NoSuchArgumentError:
self.add_message("unspecified-encoding", node=node)
if encoding_arg:
encoding_arg = utils.safe_infer(encoding_arg)
if isinstance(encoding_arg, nodes.Const) and encoding_arg.value is None:
self.add_message("unspecified-encoding", node=node)
def _check_env_function(self, node, infer):
env_name_kwarg = "key"
env_value_kwarg = "default"
if node.keywords:
kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
else:
kwargs = None
if node.args:
env_name_arg = node.args[0]
elif kwargs and env_name_kwarg in kwargs:
env_name_arg = kwargs[env_name_kwarg]
else:
env_name_arg = None
if env_name_arg:
self._check_invalid_envvar_value(
node=node,
message="invalid-envvar-value",
call_arg=utils.safe_infer(env_name_arg),
infer=infer,
allow_none=_False,
)
if len(node.args) == 2:
env_value_arg = node.args[1]
elif kwargs and env_value_kwarg in kwargs:
env_value_arg = kwargs[env_value_kwarg]
else:
env_value_arg = None
if env_value_arg:
self._check_invalid_envvar_value(
node=node,
infer=infer,
message="invalid-envvar-default",
call_arg=utils.safe_infer(env_value_arg),
allow_none=_True,
)
def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
if call_arg in (astroid.Uninferable, None):
return
name = infer.qname()
if isinstance(call_arg, nodes.Const):
emit = _False
if call_arg.value is None:
emit = not allow_none
elif not isinstance(call_arg.value, str):
emit = _True
if emit:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
else:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
def deprecated_modules(self):
"""Callback returning the deprecated modules."""
return self._deprecated_modules
def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 571 | _check_datetime | ref | function | self._check_datetime(node.operand)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 573 | check_messages | ref | function | @utils.check_messages("boolean-datetime")
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 574 | visit_if | def | function | def visit_if(self, node: nodes.If) -> None:
self._check_datetime(node.test)
@utils.check_messages("boolean-datetime")
def visit_ifexp(self, node: nodes.IfExp) -> None:
self._check_datetime(node.test)
@utils.check_messages("boolean-datetime")
def visit_boolop(self, node: nodes.BoolOp) -> None:
for value in node.values:
self._check_datetime(value)
@utils.check_messages("lru-cache-decorating-method")
def visit_functiondef(self, node: nodes.FunctionDef) -> None:
if node.decorators and isinstance(node.parent, nodes.ClassDef):
self._check_lru_cache_decorators(node.decorators)
def _check_lru_cache_decorators(self, decorators: nodes.Decorators) -> None:
"""Check if instance methods are decorated with functools.lru_cache."""
lru_cache_nodes: List[nodes.NodeNG] = []
for d_node in decorators.nodes:
try:
for infered_node in d_node.infer():
q_name = infered_node.qname()
if q_name in NON_INSTANCE_METHODS:
return
if q_name not in LRU_CACHE:
return
# Check if there is a maxsize argument to the call
if isinstance(d_node, nodes.Call):
try:
utils.get_argument_from_call(
d_node, position=0, keyword="maxsize"
)
return
except utils.NoSuchArgumentError:
pass
lru_cache_nodes.append(d_node)
break
except astroid.InferenceError:
pass
for lru_cache_node in lru_cache_nodes:
self.add_message(
"lru-cache-decorating-method",
node=lru_cache_node,
confidence=interfaces.INFERENCE,
)
def _check_redundant_assert(self, node, infer):
if (
isinstance(infer, astroid.BoundMethod)
and node.args
and isinstance(node.args[0], nodes.Const)
and infer.name in {"assert_True", "assert_False"}
):
self.add_message(
"redundant-unittest-assert",
args=(infer.name, node.args[0].value),
node=node,
)
def _check_datetime(self, node):
"""Check that a datetime was inferred.
If so, emit boolean-datetime warning.
"""
try:
inferred = next(node.infer())
except astroid.InferenceError:
return
if (
isinstance(inferred, astroid.Instance)
and inferred.qname() == "datetime.time"
):
self.add_message("boolean-datetime", node=node)
def _check_open_mode(self, node):
"""Check that the mode argument of an open or file call is valid."""
try:
mode_arg = utils.get_argument_from_call(node, position=1, keyword="mode")
except utils.NoSuchArgumentError:
return
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if isinstance(mode_arg, nodes.Const) and not _check_mode_str(
mode_arg.value
):
self.add_message(
"bad-open-mode",
node=node,
args=mode_arg.value or str(mode_arg.value),
)
def _check_open_encoded(self, node: nodes.Call, open_module: str) -> None:
"""Check that the encoded argument of an open call is valid."""
mode_arg = None
try:
if open_module == "_io":
mode_arg = utils.get_argument_from_call(
node, position=1, keyword="mode"
)
elif open_module == "pathlib":
mode_arg = utils.get_argument_from_call(
node, position=0, keyword="mode"
)
except utils.NoSuchArgumentError:
pass
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if (
not mode_arg
or isinstance(mode_arg, nodes.Const)
and (not mode_arg.value or "b" not in mode_arg.value)
):
encoding_arg = None
try:
if open_module == "pathlib":
if node.func.attrname == "read_text":
encoding_arg = utils.get_argument_from_call(
node, position=0, keyword="encoding"
)
elif node.func.attrname == "write_text":
encoding_arg = utils.get_argument_from_call(
node, position=1, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=2, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=3, keyword="encoding"
)
except utils.NoSuchArgumentError:
self.add_message("unspecified-encoding", node=node)
if encoding_arg:
encoding_arg = utils.safe_infer(encoding_arg)
if isinstance(encoding_arg, nodes.Const) and encoding_arg.value is None:
self.add_message("unspecified-encoding", node=node)
def _check_env_function(self, node, infer):
env_name_kwarg = "key"
env_value_kwarg = "default"
if node.keywords:
kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
else:
kwargs = None
if node.args:
env_name_arg = node.args[0]
elif kwargs and env_name_kwarg in kwargs:
env_name_arg = kwargs[env_name_kwarg]
else:
env_name_arg = None
if env_name_arg:
self._check_invalid_envvar_value(
node=node,
message="invalid-envvar-value",
call_arg=utils.safe_infer(env_name_arg),
infer=infer,
allow_none=_False,
)
if len(node.args) == 2:
env_value_arg = node.args[1]
elif kwargs and env_value_kwarg in kwargs:
env_value_arg = kwargs[env_value_kwarg]
else:
env_value_arg = None
if env_value_arg:
self._check_invalid_envvar_value(
node=node,
infer=infer,
message="invalid-envvar-default",
call_arg=utils.safe_infer(env_value_arg),
allow_none=_True,
)
def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
if call_arg in (astroid.Uninferable, None):
return
name = infer.qname()
if isinstance(call_arg, nodes.Const):
emit = _False
if call_arg.value is None:
emit = not allow_none
elif not isinstance(call_arg.value, str):
emit = _True
if emit:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
else:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
def deprecated_modules(self):
"""Callback returning the deprecated modules."""
return self._deprecated_modules
def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 575 | _check_datetime | ref | function | self._check_datetime(node.test)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 577 | check_messages | ref | function | @utils.check_messages("boolean-datetime")
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 578 | visit_ifexp | def | function | def visit_ifexp(self, node: nodes.IfExp) -> None:
self._check_datetime(node.test)
@utils.check_messages("boolean-datetime")
def visit_boolop(self, node: nodes.BoolOp) -> None:
for value in node.values:
self._check_datetime(value)
@utils.check_messages("lru-cache-decorating-method")
def visit_functiondef(self, node: nodes.FunctionDef) -> None:
if node.decorators and isinstance(node.parent, nodes.ClassDef):
self._check_lru_cache_decorators(node.decorators)
def _check_lru_cache_decorators(self, decorators: nodes.Decorators) -> None:
"""Check if instance methods are decorated with functools.lru_cache."""
lru_cache_nodes: List[nodes.NodeNG] = []
for d_node in decorators.nodes:
try:
for infered_node in d_node.infer():
q_name = infered_node.qname()
if q_name in NON_INSTANCE_METHODS:
return
if q_name not in LRU_CACHE:
return
# Check if there is a maxsize argument to the call
if isinstance(d_node, nodes.Call):
try:
utils.get_argument_from_call(
d_node, position=0, keyword="maxsize"
)
return
except utils.NoSuchArgumentError:
pass
lru_cache_nodes.append(d_node)
break
except astroid.InferenceError:
pass
for lru_cache_node in lru_cache_nodes:
self.add_message(
"lru-cache-decorating-method",
node=lru_cache_node,
confidence=interfaces.INFERENCE,
)
def _check_redundant_assert(self, node, infer):
if (
isinstance(infer, astroid.BoundMethod)
and node.args
and isinstance(node.args[0], nodes.Const)
and infer.name in {"assert_True", "assert_False"}
):
self.add_message(
"redundant-unittest-assert",
args=(infer.name, node.args[0].value),
node=node,
)
def _check_datetime(self, node):
"""Check that a datetime was inferred.
If so, emit boolean-datetime warning.
"""
try:
inferred = next(node.infer())
except astroid.InferenceError:
return
if (
isinstance(inferred, astroid.Instance)
and inferred.qname() == "datetime.time"
):
self.add_message("boolean-datetime", node=node)
def _check_open_mode(self, node):
"""Check that the mode argument of an open or file call is valid."""
try:
mode_arg = utils.get_argument_from_call(node, position=1, keyword="mode")
except utils.NoSuchArgumentError:
return
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if isinstance(mode_arg, nodes.Const) and not _check_mode_str(
mode_arg.value
):
self.add_message(
"bad-open-mode",
node=node,
args=mode_arg.value or str(mode_arg.value),
)
def _check_open_encoded(self, node: nodes.Call, open_module: str) -> None:
"""Check that the encoded argument of an open call is valid."""
mode_arg = None
try:
if open_module == "_io":
mode_arg = utils.get_argument_from_call(
node, position=1, keyword="mode"
)
elif open_module == "pathlib":
mode_arg = utils.get_argument_from_call(
node, position=0, keyword="mode"
)
except utils.NoSuchArgumentError:
pass
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if (
not mode_arg
or isinstance(mode_arg, nodes.Const)
and (not mode_arg.value or "b" not in mode_arg.value)
):
encoding_arg = None
try:
if open_module == "pathlib":
if node.func.attrname == "read_text":
encoding_arg = utils.get_argument_from_call(
node, position=0, keyword="encoding"
)
elif node.func.attrname == "write_text":
encoding_arg = utils.get_argument_from_call(
node, position=1, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=2, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=3, keyword="encoding"
)
except utils.NoSuchArgumentError:
self.add_message("unspecified-encoding", node=node)
if encoding_arg:
encoding_arg = utils.safe_infer(encoding_arg)
if isinstance(encoding_arg, nodes.Const) and encoding_arg.value is None:
self.add_message("unspecified-encoding", node=node)
def _check_env_function(self, node, infer):
env_name_kwarg = "key"
env_value_kwarg = "default"
if node.keywords:
kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
else:
kwargs = None
if node.args:
env_name_arg = node.args[0]
elif kwargs and env_name_kwarg in kwargs:
env_name_arg = kwargs[env_name_kwarg]
else:
env_name_arg = None
if env_name_arg:
self._check_invalid_envvar_value(
node=node,
message="invalid-envvar-value",
call_arg=utils.safe_infer(env_name_arg),
infer=infer,
allow_none=_False,
)
if len(node.args) == 2:
env_value_arg = node.args[1]
elif kwargs and env_value_kwarg in kwargs:
env_value_arg = kwargs[env_value_kwarg]
else:
env_value_arg = None
if env_value_arg:
self._check_invalid_envvar_value(
node=node,
infer=infer,
message="invalid-envvar-default",
call_arg=utils.safe_infer(env_value_arg),
allow_none=_True,
)
def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
if call_arg in (astroid.Uninferable, None):
return
name = infer.qname()
if isinstance(call_arg, nodes.Const):
emit = _False
if call_arg.value is None:
emit = not allow_none
elif not isinstance(call_arg.value, str):
emit = _True
if emit:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
else:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
def deprecated_modules(self):
"""Callback returning the deprecated modules."""
return self._deprecated_modules
def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 579 | _check_datetime | ref | function | self._check_datetime(node.test)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 581 | check_messages | ref | function | @utils.check_messages("boolean-datetime")
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 582 | visit_boolop | def | function | def visit_boolop(self, node: nodes.BoolOp) -> None:
for value in node.values:
self._check_datetime(value)
@utils.check_messages("lru-cache-decorating-method")
def visit_functiondef(self, node: nodes.FunctionDef) -> None:
if node.decorators and isinstance(node.parent, nodes.ClassDef):
self._check_lru_cache_decorators(node.decorators)
def _check_lru_cache_decorators(self, decorators: nodes.Decorators) -> None:
"""Check if instance methods are decorated with functools.lru_cache."""
lru_cache_nodes: List[nodes.NodeNG] = []
for d_node in decorators.nodes:
try:
for infered_node in d_node.infer():
q_name = infered_node.qname()
if q_name in NON_INSTANCE_METHODS:
return
if q_name not in LRU_CACHE:
return
# Check if there is a maxsize argument to the call
if isinstance(d_node, nodes.Call):
try:
utils.get_argument_from_call(
d_node, position=0, keyword="maxsize"
)
return
except utils.NoSuchArgumentError:
pass
lru_cache_nodes.append(d_node)
break
except astroid.InferenceError:
pass
for lru_cache_node in lru_cache_nodes:
self.add_message(
"lru-cache-decorating-method",
node=lru_cache_node,
confidence=interfaces.INFERENCE,
)
def _check_redundant_assert(self, node, infer):
if (
isinstance(infer, astroid.BoundMethod)
and node.args
and isinstance(node.args[0], nodes.Const)
and infer.name in {"assert_True", "assert_False"}
):
self.add_message(
"redundant-unittest-assert",
args=(infer.name, node.args[0].value),
node=node,
)
def _check_datetime(self, node):
"""Check that a datetime was inferred.
If so, emit boolean-datetime warning.
"""
try:
inferred = next(node.infer())
except astroid.InferenceError:
return
if (
isinstance(inferred, astroid.Instance)
and inferred.qname() == "datetime.time"
):
self.add_message("boolean-datetime", node=node)
def _check_open_mode(self, node):
"""Check that the mode argument of an open or file call is valid."""
try:
mode_arg = utils.get_argument_from_call(node, position=1, keyword="mode")
except utils.NoSuchArgumentError:
return
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if isinstance(mode_arg, nodes.Const) and not _check_mode_str(
mode_arg.value
):
self.add_message(
"bad-open-mode",
node=node,
args=mode_arg.value or str(mode_arg.value),
)
def _check_open_encoded(self, node: nodes.Call, open_module: str) -> None:
"""Check that the encoded argument of an open call is valid."""
mode_arg = None
try:
if open_module == "_io":
mode_arg = utils.get_argument_from_call(
node, position=1, keyword="mode"
)
elif open_module == "pathlib":
mode_arg = utils.get_argument_from_call(
node, position=0, keyword="mode"
)
except utils.NoSuchArgumentError:
pass
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if (
not mode_arg
or isinstance(mode_arg, nodes.Const)
and (not mode_arg.value or "b" not in mode_arg.value)
):
encoding_arg = None
try:
if open_module == "pathlib":
if node.func.attrname == "read_text":
encoding_arg = utils.get_argument_from_call(
node, position=0, keyword="encoding"
)
elif node.func.attrname == "write_text":
encoding_arg = utils.get_argument_from_call(
node, position=1, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=2, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=3, keyword="encoding"
)
except utils.NoSuchArgumentError:
self.add_message("unspecified-encoding", node=node)
if encoding_arg:
encoding_arg = utils.safe_infer(encoding_arg)
if isinstance(encoding_arg, nodes.Const) and encoding_arg.value is None:
self.add_message("unspecified-encoding", node=node)
def _check_env_function(self, node, infer):
env_name_kwarg = "key"
env_value_kwarg = "default"
if node.keywords:
kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
else:
kwargs = None
if node.args:
env_name_arg = node.args[0]
elif kwargs and env_name_kwarg in kwargs:
env_name_arg = kwargs[env_name_kwarg]
else:
env_name_arg = None
if env_name_arg:
self._check_invalid_envvar_value(
node=node,
message="invalid-envvar-value",
call_arg=utils.safe_infer(env_name_arg),
infer=infer,
allow_none=_False,
)
if len(node.args) == 2:
env_value_arg = node.args[1]
elif kwargs and env_value_kwarg in kwargs:
env_value_arg = kwargs[env_value_kwarg]
else:
env_value_arg = None
if env_value_arg:
self._check_invalid_envvar_value(
node=node,
infer=infer,
message="invalid-envvar-default",
call_arg=utils.safe_infer(env_value_arg),
allow_none=_True,
)
def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
if call_arg in (astroid.Uninferable, None):
return
name = infer.qname()
if isinstance(call_arg, nodes.Const):
emit = _False
if call_arg.value is None:
emit = not allow_none
elif not isinstance(call_arg.value, str):
emit = _True
if emit:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
else:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
def deprecated_modules(self):
"""Callback returning the deprecated modules."""
return self._deprecated_modules
def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 584 | _check_datetime | ref | function | self._check_datetime(value)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 586 | check_messages | ref | function | @utils.check_messages("lru-cache-decorating-method")
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 587 | visit_functiondef | def | function | def visit_functiondef(self, node: nodes.FunctionDef) -> None:
if node.decorators and isinstance(node.parent, nodes.ClassDef):
self._check_lru_cache_decorators(node.decorators)
def _check_lru_cache_decorators(self, decorators: nodes.Decorators) -> None:
"""Check if instance methods are decorated with functools.lru_cache."""
lru_cache_nodes: List[nodes.NodeNG] = []
for d_node in decorators.nodes:
try:
for infered_node in d_node.infer():
q_name = infered_node.qname()
if q_name in NON_INSTANCE_METHODS:
return
if q_name not in LRU_CACHE:
return
# Check if there is a maxsize argument to the call
if isinstance(d_node, nodes.Call):
try:
utils.get_argument_from_call(
d_node, position=0, keyword="maxsize"
)
return
except utils.NoSuchArgumentError:
pass
lru_cache_nodes.append(d_node)
break
except astroid.InferenceError:
pass
for lru_cache_node in lru_cache_nodes:
self.add_message(
"lru-cache-decorating-method",
node=lru_cache_node,
confidence=interfaces.INFERENCE,
)
def _check_redundant_assert(self, node, infer):
if (
isinstance(infer, astroid.BoundMethod)
and node.args
and isinstance(node.args[0], nodes.Const)
and infer.name in {"assert_True", "assert_False"}
):
self.add_message(
"redundant-unittest-assert",
args=(infer.name, node.args[0].value),
node=node,
)
def _check_datetime(self, node):
"""Check that a datetime was inferred.
If so, emit boolean-datetime warning.
"""
try:
inferred = next(node.infer())
except astroid.InferenceError:
return
if (
isinstance(inferred, astroid.Instance)
and inferred.qname() == "datetime.time"
):
self.add_message("boolean-datetime", node=node)
def _check_open_mode(self, node):
"""Check that the mode argument of an open or file call is valid."""
try:
mode_arg = utils.get_argument_from_call(node, position=1, keyword="mode")
except utils.NoSuchArgumentError:
return
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if isinstance(mode_arg, nodes.Const) and not _check_mode_str(
mode_arg.value
):
self.add_message(
"bad-open-mode",
node=node,
args=mode_arg.value or str(mode_arg.value),
)
def _check_open_encoded(self, node: nodes.Call, open_module: str) -> None:
"""Check that the encoded argument of an open call is valid."""
mode_arg = None
try:
if open_module == "_io":
mode_arg = utils.get_argument_from_call(
node, position=1, keyword="mode"
)
elif open_module == "pathlib":
mode_arg = utils.get_argument_from_call(
node, position=0, keyword="mode"
)
except utils.NoSuchArgumentError:
pass
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if (
not mode_arg
or isinstance(mode_arg, nodes.Const)
and (not mode_arg.value or "b" not in mode_arg.value)
):
encoding_arg = None
try:
if open_module == "pathlib":
if node.func.attrname == "read_text":
encoding_arg = utils.get_argument_from_call(
node, position=0, keyword="encoding"
)
elif node.func.attrname == "write_text":
encoding_arg = utils.get_argument_from_call(
node, position=1, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=2, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=3, keyword="encoding"
)
except utils.NoSuchArgumentError:
self.add_message("unspecified-encoding", node=node)
if encoding_arg:
encoding_arg = utils.safe_infer(encoding_arg)
if isinstance(encoding_arg, nodes.Const) and encoding_arg.value is None:
self.add_message("unspecified-encoding", node=node)
def _check_env_function(self, node, infer):
env_name_kwarg = "key"
env_value_kwarg = "default"
if node.keywords:
kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
else:
kwargs = None
if node.args:
env_name_arg = node.args[0]
elif kwargs and env_name_kwarg in kwargs:
env_name_arg = kwargs[env_name_kwarg]
else:
env_name_arg = None
if env_name_arg:
self._check_invalid_envvar_value(
node=node,
message="invalid-envvar-value",
call_arg=utils.safe_infer(env_name_arg),
infer=infer,
allow_none=_False,
)
if len(node.args) == 2:
env_value_arg = node.args[1]
elif kwargs and env_value_kwarg in kwargs:
env_value_arg = kwargs[env_value_kwarg]
else:
env_value_arg = None
if env_value_arg:
self._check_invalid_envvar_value(
node=node,
infer=infer,
message="invalid-envvar-default",
call_arg=utils.safe_infer(env_value_arg),
allow_none=_True,
)
def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
if call_arg in (astroid.Uninferable, None):
return
name = infer.qname()
if isinstance(call_arg, nodes.Const):
emit = _False
if call_arg.value is None:
emit = not allow_none
elif not isinstance(call_arg.value, str):
emit = _True
if emit:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
else:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
def deprecated_modules(self):
"""Callback returning the deprecated modules."""
return self._deprecated_modules
def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 589 | _check_lru_cache_decorators | ref | function | self._check_lru_cache_decorators(node.decorators)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 591 | _check_lru_cache_decorators | def | function | def _check_lru_cache_decorators(self, decorators: nodes.Decorators) -> None:
"""Check if instance methods are decorated with functools.lru_cache."""
lru_cache_nodes: List[nodes.NodeNG] = []
for d_node in decorators.nodes:
try:
for infered_node in d_node.infer():
q_name = infered_node.qname()
if q_name in NON_INSTANCE_METHODS:
return
if q_name not in LRU_CACHE:
return
# Check if there is a maxsize argument to the call
if isinstance(d_node, nodes.Call):
try:
utils.get_argument_from_call(
d_node, position=0, keyword="maxsize"
)
return
except utils.NoSuchArgumentError:
pass
lru_cache_nodes.append(d_node)
break
except astroid.InferenceError:
pass
for lru_cache_node in lru_cache_nodes:
self.add_message(
"lru-cache-decorating-method",
node=lru_cache_node,
confidence=interfaces.INFERENCE,
)
def _check_redundant_assert(self, node, infer):
if (
isinstance(infer, astroid.BoundMethod)
and node.args
and isinstance(node.args[0], nodes.Const)
and infer.name in {"assert_True", "assert_False"}
):
self.add_message(
"redundant-unittest-assert",
args=(infer.name, node.args[0].value),
node=node,
)
def _check_datetime(self, node):
"""Check that a datetime was inferred.
If so, emit boolean-datetime warning.
"""
try:
inferred = next(node.infer())
except astroid.InferenceError:
return
if (
isinstance(inferred, astroid.Instance)
and inferred.qname() == "datetime.time"
):
self.add_message("boolean-datetime", node=node)
def _check_open_mode(self, node):
"""Check that the mode argument of an open or file call is valid."""
try:
mode_arg = utils.get_argument_from_call(node, position=1, keyword="mode")
except utils.NoSuchArgumentError:
return
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if isinstance(mode_arg, nodes.Const) and not _check_mode_str(
mode_arg.value
):
self.add_message(
"bad-open-mode",
node=node,
args=mode_arg.value or str(mode_arg.value),
)
def _check_open_encoded(self, node: nodes.Call, open_module: str) -> None:
"""Check that the encoded argument of an open call is valid."""
mode_arg = None
try:
if open_module == "_io":
mode_arg = utils.get_argument_from_call(
node, position=1, keyword="mode"
)
elif open_module == "pathlib":
mode_arg = utils.get_argument_from_call(
node, position=0, keyword="mode"
)
except utils.NoSuchArgumentError:
pass
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if (
not mode_arg
or isinstance(mode_arg, nodes.Const)
and (not mode_arg.value or "b" not in mode_arg.value)
):
encoding_arg = None
try:
if open_module == "pathlib":
if node.func.attrname == "read_text":
encoding_arg = utils.get_argument_from_call(
node, position=0, keyword="encoding"
)
elif node.func.attrname == "write_text":
encoding_arg = utils.get_argument_from_call(
node, position=1, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=2, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=3, keyword="encoding"
)
except utils.NoSuchArgumentError:
self.add_message("unspecified-encoding", node=node)
if encoding_arg:
encoding_arg = utils.safe_infer(encoding_arg)
if isinstance(encoding_arg, nodes.Const) and encoding_arg.value is None:
self.add_message("unspecified-encoding", node=node)
def _check_env_function(self, node, infer):
env_name_kwarg = "key"
env_value_kwarg = "default"
if node.keywords:
kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
else:
kwargs = None
if node.args:
env_name_arg = node.args[0]
elif kwargs and env_name_kwarg in kwargs:
env_name_arg = kwargs[env_name_kwarg]
else:
env_name_arg = None
if env_name_arg:
self._check_invalid_envvar_value(
node=node,
message="invalid-envvar-value",
call_arg=utils.safe_infer(env_name_arg),
infer=infer,
allow_none=_False,
)
if len(node.args) == 2:
env_value_arg = node.args[1]
elif kwargs and env_value_kwarg in kwargs:
env_value_arg = kwargs[env_value_kwarg]
else:
env_value_arg = None
if env_value_arg:
self._check_invalid_envvar_value(
node=node,
infer=infer,
message="invalid-envvar-default",
call_arg=utils.safe_infer(env_value_arg),
allow_none=_True,
)
def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
if call_arg in (astroid.Uninferable, None):
return
name = infer.qname()
if isinstance(call_arg, nodes.Const):
emit = _False
if call_arg.value is None:
emit = not allow_none
elif not isinstance(call_arg.value, str):
emit = _True
if emit:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
else:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
def deprecated_modules(self):
"""Callback returning the deprecated modules."""
return self._deprecated_modules
def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 596 | infer | ref | function | for infered_node in d_node.infer():
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 597 | qname | ref | function | q_name = infered_node.qname()
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 606 | get_argument_from_call | ref | function | utils.get_argument_from_call(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 618 | add_message | ref | function | self.add_message(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 624 | _check_redundant_assert | def | function | def _check_redundant_assert(self, node, infer):
if (
isinstance(infer, astroid.BoundMethod)
and node.args
and isinstance(node.args[0], nodes.Const)
and infer.name in {"assert_True", "assert_False"}
):
self.add_message(
"redundant-unittest-assert",
args=(infer.name, node.args[0].value),
node=node,
)
def _check_datetime(self, node):
"""Check that a datetime was inferred.
If so, emit boolean-datetime warning.
"""
try:
inferred = next(node.infer())
except astroid.InferenceError:
return
if (
isinstance(inferred, astroid.Instance)
and inferred.qname() == "datetime.time"
):
self.add_message("boolean-datetime", node=node)
def _check_open_mode(self, node):
"""Check that the mode argument of an open or file call is valid."""
try:
mode_arg = utils.get_argument_from_call(node, position=1, keyword="mode")
except utils.NoSuchArgumentError:
return
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if isinstance(mode_arg, nodes.Const) and not _check_mode_str(
mode_arg.value
):
self.add_message(
"bad-open-mode",
node=node,
args=mode_arg.value or str(mode_arg.value),
)
def _check_open_encoded(self, node: nodes.Call, open_module: str) -> None:
"""Check that the encoded argument of an open call is valid."""
mode_arg = None
try:
if open_module == "_io":
mode_arg = utils.get_argument_from_call(
node, position=1, keyword="mode"
)
elif open_module == "pathlib":
mode_arg = utils.get_argument_from_call(
node, position=0, keyword="mode"
)
except utils.NoSuchArgumentError:
pass
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if (
not mode_arg
or isinstance(mode_arg, nodes.Const)
and (not mode_arg.value or "b" not in mode_arg.value)
):
encoding_arg = None
try:
if open_module == "pathlib":
if node.func.attrname == "read_text":
encoding_arg = utils.get_argument_from_call(
node, position=0, keyword="encoding"
)
elif node.func.attrname == "write_text":
encoding_arg = utils.get_argument_from_call(
node, position=1, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=2, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=3, keyword="encoding"
)
except utils.NoSuchArgumentError:
self.add_message("unspecified-encoding", node=node)
if encoding_arg:
encoding_arg = utils.safe_infer(encoding_arg)
if isinstance(encoding_arg, nodes.Const) and encoding_arg.value is None:
self.add_message("unspecified-encoding", node=node)
def _check_env_function(self, node, infer):
env_name_kwarg = "key"
env_value_kwarg = "default"
if node.keywords:
kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
else:
kwargs = None
if node.args:
env_name_arg = node.args[0]
elif kwargs and env_name_kwarg in kwargs:
env_name_arg = kwargs[env_name_kwarg]
else:
env_name_arg = None
if env_name_arg:
self._check_invalid_envvar_value(
node=node,
message="invalid-envvar-value",
call_arg=utils.safe_infer(env_name_arg),
infer=infer,
allow_none=_False,
)
if len(node.args) == 2:
env_value_arg = node.args[1]
elif kwargs and env_value_kwarg in kwargs:
env_value_arg = kwargs[env_value_kwarg]
else:
env_value_arg = None
if env_value_arg:
self._check_invalid_envvar_value(
node=node,
infer=infer,
message="invalid-envvar-default",
call_arg=utils.safe_infer(env_value_arg),
allow_none=_True,
)
def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
if call_arg in (astroid.Uninferable, None):
return
name = infer.qname()
if isinstance(call_arg, nodes.Const):
emit = _False
if call_arg.value is None:
emit = not allow_none
elif not isinstance(call_arg.value, str):
emit = _True
if emit:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
else:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
def deprecated_modules(self):
"""Callback returning the deprecated modules."""
return self._deprecated_modules
def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 631 | add_message | ref | function | self.add_message(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 637 | _check_datetime | def | function | def _check_datetime(self, node):
"""Check that a datetime was inferred.
If so, emit boolean-datetime warning.
"""
try:
inferred = next(node.infer())
except astroid.InferenceError:
return
if (
isinstance(inferred, astroid.Instance)
and inferred.qname() == "datetime.time"
):
self.add_message("boolean-datetime", node=node)
def _check_open_mode(self, node):
"""Check that the mode argument of an open or file call is valid."""
try:
mode_arg = utils.get_argument_from_call(node, position=1, keyword="mode")
except utils.NoSuchArgumentError:
return
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if isinstance(mode_arg, nodes.Const) and not _check_mode_str(
mode_arg.value
):
self.add_message(
"bad-open-mode",
node=node,
args=mode_arg.value or str(mode_arg.value),
)
def _check_open_encoded(self, node: nodes.Call, open_module: str) -> None:
"""Check that the encoded argument of an open call is valid."""
mode_arg = None
try:
if open_module == "_io":
mode_arg = utils.get_argument_from_call(
node, position=1, keyword="mode"
)
elif open_module == "pathlib":
mode_arg = utils.get_argument_from_call(
node, position=0, keyword="mode"
)
except utils.NoSuchArgumentError:
pass
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if (
not mode_arg
or isinstance(mode_arg, nodes.Const)
and (not mode_arg.value or "b" not in mode_arg.value)
):
encoding_arg = None
try:
if open_module == "pathlib":
if node.func.attrname == "read_text":
encoding_arg = utils.get_argument_from_call(
node, position=0, keyword="encoding"
)
elif node.func.attrname == "write_text":
encoding_arg = utils.get_argument_from_call(
node, position=1, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=2, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=3, keyword="encoding"
)
except utils.NoSuchArgumentError:
self.add_message("unspecified-encoding", node=node)
if encoding_arg:
encoding_arg = utils.safe_infer(encoding_arg)
if isinstance(encoding_arg, nodes.Const) and encoding_arg.value is None:
self.add_message("unspecified-encoding", node=node)
def _check_env_function(self, node, infer):
env_name_kwarg = "key"
env_value_kwarg = "default"
if node.keywords:
kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
else:
kwargs = None
if node.args:
env_name_arg = node.args[0]
elif kwargs and env_name_kwarg in kwargs:
env_name_arg = kwargs[env_name_kwarg]
else:
env_name_arg = None
if env_name_arg:
self._check_invalid_envvar_value(
node=node,
message="invalid-envvar-value",
call_arg=utils.safe_infer(env_name_arg),
infer=infer,
allow_none=_False,
)
if len(node.args) == 2:
env_value_arg = node.args[1]
elif kwargs and env_value_kwarg in kwargs:
env_value_arg = kwargs[env_value_kwarg]
else:
env_value_arg = None
if env_value_arg:
self._check_invalid_envvar_value(
node=node,
infer=infer,
message="invalid-envvar-default",
call_arg=utils.safe_infer(env_value_arg),
allow_none=_True,
)
def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
if call_arg in (astroid.Uninferable, None):
return
name = infer.qname()
if isinstance(call_arg, nodes.Const):
emit = _False
if call_arg.value is None:
emit = not allow_none
elif not isinstance(call_arg.value, str):
emit = _True
if emit:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
else:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
def deprecated_modules(self):
"""Callback returning the deprecated modules."""
return self._deprecated_modules
def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 642 | infer | ref | function | inferred = next(node.infer())
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 647 | qname | ref | function | and inferred.qname() == "datetime.time"
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 649 | add_message | ref | function | self.add_message("boolean-datetime", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 651 | _check_open_mode | def | function | def _check_open_mode(self, node):
"""Check that the mode argument of an open or file call is valid."""
try:
mode_arg = utils.get_argument_from_call(node, position=1, keyword="mode")
except utils.NoSuchArgumentError:
return
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if isinstance(mode_arg, nodes.Const) and not _check_mode_str(
mode_arg.value
):
self.add_message(
"bad-open-mode",
node=node,
args=mode_arg.value or str(mode_arg.value),
)
def _check_open_encoded(self, node: nodes.Call, open_module: str) -> None:
"""Check that the encoded argument of an open call is valid."""
mode_arg = None
try:
if open_module == "_io":
mode_arg = utils.get_argument_from_call(
node, position=1, keyword="mode"
)
elif open_module == "pathlib":
mode_arg = utils.get_argument_from_call(
node, position=0, keyword="mode"
)
except utils.NoSuchArgumentError:
pass
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if (
not mode_arg
or isinstance(mode_arg, nodes.Const)
and (not mode_arg.value or "b" not in mode_arg.value)
):
encoding_arg = None
try:
if open_module == "pathlib":
if node.func.attrname == "read_text":
encoding_arg = utils.get_argument_from_call(
node, position=0, keyword="encoding"
)
elif node.func.attrname == "write_text":
encoding_arg = utils.get_argument_from_call(
node, position=1, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=2, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=3, keyword="encoding"
)
except utils.NoSuchArgumentError:
self.add_message("unspecified-encoding", node=node)
if encoding_arg:
encoding_arg = utils.safe_infer(encoding_arg)
if isinstance(encoding_arg, nodes.Const) and encoding_arg.value is None:
self.add_message("unspecified-encoding", node=node)
def _check_env_function(self, node, infer):
env_name_kwarg = "key"
env_value_kwarg = "default"
if node.keywords:
kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
else:
kwargs = None
if node.args:
env_name_arg = node.args[0]
elif kwargs and env_name_kwarg in kwargs:
env_name_arg = kwargs[env_name_kwarg]
else:
env_name_arg = None
if env_name_arg:
self._check_invalid_envvar_value(
node=node,
message="invalid-envvar-value",
call_arg=utils.safe_infer(env_name_arg),
infer=infer,
allow_none=_False,
)
if len(node.args) == 2:
env_value_arg = node.args[1]
elif kwargs and env_value_kwarg in kwargs:
env_value_arg = kwargs[env_value_kwarg]
else:
env_value_arg = None
if env_value_arg:
self._check_invalid_envvar_value(
node=node,
infer=infer,
message="invalid-envvar-default",
call_arg=utils.safe_infer(env_value_arg),
allow_none=_True,
)
def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
if call_arg in (astroid.Uninferable, None):
return
name = infer.qname()
if isinstance(call_arg, nodes.Const):
emit = _False
if call_arg.value is None:
emit = not allow_none
elif not isinstance(call_arg.value, str):
emit = _True
if emit:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
else:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
def deprecated_modules(self):
"""Callback returning the deprecated modules."""
return self._deprecated_modules
def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 654 | get_argument_from_call | ref | function | mode_arg = utils.get_argument_from_call(node, position=1, keyword="mode")
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 658 | safe_infer | ref | function | mode_arg = utils.safe_infer(mode_arg)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 659 | _check_mode_str | ref | function | if isinstance(mode_arg, nodes.Const) and not _check_mode_str(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 662 | add_message | ref | function | self.add_message(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 668 | _check_open_encoded | def | function | def _check_open_encoded(self, node: nodes.Call, open_module: str) -> None:
"""Check that the encoded argument of an open call is valid."""
mode_arg = None
try:
if open_module == "_io":
mode_arg = utils.get_argument_from_call(
node, position=1, keyword="mode"
)
elif open_module == "pathlib":
mode_arg = utils.get_argument_from_call(
node, position=0, keyword="mode"
)
except utils.NoSuchArgumentError:
pass
if mode_arg:
mode_arg = utils.safe_infer(mode_arg)
if (
not mode_arg
or isinstance(mode_arg, nodes.Const)
and (not mode_arg.value or "b" not in mode_arg.value)
):
encoding_arg = None
try:
if open_module == "pathlib":
if node.func.attrname == "read_text":
encoding_arg = utils.get_argument_from_call(
node, position=0, keyword="encoding"
)
elif node.func.attrname == "write_text":
encoding_arg = utils.get_argument_from_call(
node, position=1, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=2, keyword="encoding"
)
else:
encoding_arg = utils.get_argument_from_call(
node, position=3, keyword="encoding"
)
except utils.NoSuchArgumentError:
self.add_message("unspecified-encoding", node=node)
if encoding_arg:
encoding_arg = utils.safe_infer(encoding_arg)
if isinstance(encoding_arg, nodes.Const) and encoding_arg.value is None:
self.add_message("unspecified-encoding", node=node)
def _check_env_function(self, node, infer):
env_name_kwarg = "key"
env_value_kwarg = "default"
if node.keywords:
kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
else:
kwargs = None
if node.args:
env_name_arg = node.args[0]
elif kwargs and env_name_kwarg in kwargs:
env_name_arg = kwargs[env_name_kwarg]
else:
env_name_arg = None
if env_name_arg:
self._check_invalid_envvar_value(
node=node,
message="invalid-envvar-value",
call_arg=utils.safe_infer(env_name_arg),
infer=infer,
allow_none=_False,
)
if len(node.args) == 2:
env_value_arg = node.args[1]
elif kwargs and env_value_kwarg in kwargs:
env_value_arg = kwargs[env_value_kwarg]
else:
env_value_arg = None
if env_value_arg:
self._check_invalid_envvar_value(
node=node,
infer=infer,
message="invalid-envvar-default",
call_arg=utils.safe_infer(env_value_arg),
allow_none=_True,
)
def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
if call_arg in (astroid.Uninferable, None):
return
name = infer.qname()
if isinstance(call_arg, nodes.Const):
emit = _False
if call_arg.value is None:
emit = not allow_none
elif not isinstance(call_arg.value, str):
emit = _True
if emit:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
else:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
def deprecated_modules(self):
"""Callback returning the deprecated modules."""
return self._deprecated_modules
def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 673 | get_argument_from_call | ref | function | mode_arg = utils.get_argument_from_call(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 677 | get_argument_from_call | ref | function | mode_arg = utils.get_argument_from_call(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 684 | safe_infer | ref | function | mode_arg = utils.safe_infer(mode_arg)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 695 | get_argument_from_call | ref | function | encoding_arg = utils.get_argument_from_call(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 699 | get_argument_from_call | ref | function | encoding_arg = utils.get_argument_from_call(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 703 | get_argument_from_call | ref | function | encoding_arg = utils.get_argument_from_call(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 707 | get_argument_from_call | ref | function | encoding_arg = utils.get_argument_from_call(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 711 | add_message | ref | function | self.add_message("unspecified-encoding", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 714 | safe_infer | ref | function | encoding_arg = utils.safe_infer(encoding_arg)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 717 | add_message | ref | function | self.add_message("unspecified-encoding", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 719 | _check_env_function | def | function | def _check_env_function(self, node, infer):
env_name_kwarg = "key"
env_value_kwarg = "default"
if node.keywords:
kwargs = {keyword.arg: keyword.value for keyword in node.keywords}
else:
kwargs = None
if node.args:
env_name_arg = node.args[0]
elif kwargs and env_name_kwarg in kwargs:
env_name_arg = kwargs[env_name_kwarg]
else:
env_name_arg = None
if env_name_arg:
self._check_invalid_envvar_value(
node=node,
message="invalid-envvar-value",
call_arg=utils.safe_infer(env_name_arg),
infer=infer,
allow_none=_False,
)
if len(node.args) == 2:
env_value_arg = node.args[1]
elif kwargs and env_value_kwarg in kwargs:
env_value_arg = kwargs[env_value_kwarg]
else:
env_value_arg = None
if env_value_arg:
self._check_invalid_envvar_value(
node=node,
infer=infer,
message="invalid-envvar-default",
call_arg=utils.safe_infer(env_value_arg),
allow_none=_True,
)
def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
if call_arg in (astroid.Uninferable, None):
return
name = infer.qname()
if isinstance(call_arg, nodes.Const):
emit = _False
if call_arg.value is None:
emit = not allow_none
elif not isinstance(call_arg.value, str):
emit = _True
if emit:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
else:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
def deprecated_modules(self):
"""Callback returning the deprecated modules."""
return self._deprecated_modules
def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 734 | _check_invalid_envvar_value | ref | function | self._check_invalid_envvar_value(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 737 | safe_infer | ref | function | call_arg=utils.safe_infer(env_name_arg),
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 750 | _check_invalid_envvar_value | ref | function | self._check_invalid_envvar_value(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 754 | safe_infer | ref | function | call_arg=utils.safe_infer(env_value_arg),
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 758 | _check_invalid_envvar_value | def | function | def _check_invalid_envvar_value(self, node, infer, message, call_arg, allow_none):
if call_arg in (astroid.Uninferable, None):
return
name = infer.qname()
if isinstance(call_arg, nodes.Const):
emit = _False
if call_arg.value is None:
emit = not allow_none
elif not isinstance(call_arg.value, str):
emit = _True
if emit:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
else:
self.add_message(message, node=node, args=(name, call_arg.pytype()))
def deprecated_modules(self):
"""Callback returning the deprecated modules."""
return self._deprecated_modules
def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 762 | qname | ref | function | name = infer.qname()
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 770 | add_message | ref | function | self.add_message(message, node=node, args=(name, call_arg.pytype()))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 770 | pytype | ref | function | self.add_message(message, node=node, args=(name, call_arg.pytype()))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 772 | add_message | ref | function | self.add_message(message, node=node, args=(name, call_arg.pytype()))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 772 | pytype | ref | function | self.add_message(message, node=node, args=(name, call_arg.pytype()))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 774 | deprecated_modules | def | function | def deprecated_modules(self):
"""Callback returning the deprecated modules."""
return self._deprecated_modules
def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 778 | deprecated_methods | def | function | def deprecated_methods(self):
return self._deprecated_methods
def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 781 | deprecated_arguments | def | function | def deprecated_arguments(self, method: str):
return self._deprecated_attributes.get(method, ())
def deprecated_classes(self, module: str):
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 784 | deprecated_classes | def | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 787 | deprecated_decorators | def | function | def deprecated_decorators(self) -> Iterable:
return self._deprecated_decorators
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 791 | register | def | function | def register(linter: "PyLinter") -> None:
linter.register_checker(StdlibChecker(linter))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 792 | register_checker | ref | function | linter.register_checker(StdlibChecker(linter))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/stdlib.py | pylint/checkers/stdlib.py | 792 | StdlibChecker | ref | function | linter.register_checker(StdlibChecker(linter))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 227 | get_access_path | def | function | def get_access_path(key, parts):
"""Given a list of format specifiers, returns
the final access path (e.g. a.b.c[0][1]).
"""
path = []
for is_attribute, specifier in parts:
if is_attribute:
path.append(f".{specifier}")
else:
path.append(f"[{specifier!r}]")
return str(key) + "".join(path)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 240 | arg_matches_format_type | def | function | def arg_matches_format_type(arg_type, format_type):
if format_type in "sr":
# All types can be printed with %s and %r
return _True
if isinstance(arg_type, astroid.Instance):
arg_type = arg_type.pytype()
if arg_type == "builtins.str":
return format_type == "c"
if arg_type == "builtins.float":
return format_type in "deEfFgGn%"
if arg_type == "builtins.int":
# Integers allow all types
return _True
return _False
return _True
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 245 | pytype | ref | function | arg_type = arg_type.pytype()
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 257 | StringFormatChecker | def | class | visit_binop visit_joinedstr _check_interpolation visit_call _detect_vacuous_formatting _check_new_format _check_new_format_specifiers |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 267 | check_messages | ref | function | @check_messages(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 281 | visit_binop | def | function | def visit_binop(self, node: nodes.BinOp) -> None:
if node.op != "%":
return
left = node.left
args = node.right
if not (isinstance(left, nodes.Const) and isinstance(left.value, str)):
return
format_string = left.value
try:
(
required_keys,
required_num_args,
required_key_types,
required_arg_types,
) = utils.parse_format_string(format_string)
except utils.UnsupportedFormatCharacter as exc:
formatted = format_string[exc.index]
self.add_message(
"bad-format-character",
node=node,
args=(formatted, ord(formatted), exc.index),
)
return
except utils.IncompleteFormatString:
self.add_message("truncated-format-string", node=node)
return
if not required_keys and not required_num_args:
self.add_message("format-string-without-interpolation", node=node)
return
if required_keys and required_num_args:
# The format string uses both named and unnamed format
# specifiers.
self.add_message("mixed-format-string", node=node)
elif required_keys:
# The format string uses only named format specifiers.
# Check that the RHS of the % operator is a mapping object
# that contains precisely the set of keys required by the
# format string.
if isinstance(args, nodes.Dict):
keys = set()
unknown_keys = _False
for k, _ in args.items:
if isinstance(k, nodes.Const):
key = k.value
if isinstance(key, str):
keys.add(key)
else:
self.add_message(
"bad-format-string-key", node=node, args=key
)
else:
# One of the keys was something other than a
# constant. Since we can't tell what it is,
# suppress checks for missing keys in the
# dictionary.
unknown_keys = _True
if not unknown_keys:
for key in required_keys:
if key not in keys:
self.add_message(
"missing-format-string-key", node=node, args=key
)
for key in keys:
if key not in required_keys:
self.add_message(
"unused-format-string-key", node=node, args=key
)
for key, arg in args.items:
if not isinstance(key, nodes.Const):
continue
format_type = required_key_types.get(key.value, None)
arg_type = utils.safe_infer(arg)
if (
format_type is not None
and arg_type
and arg_type != astroid.Uninferable
and not arg_matches_format_type(arg_type, format_type)
):
self.add_message(
"bad-string-format-type",
node=node,
args=(arg_type.pytype(), format_type),
)
elif isinstance(args, (OTHER_NODES, nodes.Tuple)):
type_name = type(args).__name__
self.add_message("format-needs-mapping", node=node, args=type_name)
# else:
# The RHS of the format specifier is a name or
# expression. It may be a mapping object, so
# there's nothing we can check.
else:
# The format string uses only unnamed format specifiers.
# Check that the number of arguments passed to the RHS of
# the % operator matches the number required by the format
# string.
args_elts = []
if isinstance(args, nodes.Tuple):
rhs_tuple = utils.safe_infer(args)
num_args = None
if isinstance(rhs_tuple, nodes.BaseContainer):
args_elts = rhs_tuple.elts
num_args = len(args_elts)
elif isinstance(args, (OTHER_NODES, (nodes.Dict, nodes.DictComp))):
args_elts = [args]
num_args = 1
else:
# The RHS of the format specifier is a name or
# expression. It could be a tuple of unknown size, so
# there's nothing we can check.
num_args = None
if num_args is not None:
if num_args > required_num_args:
self.add_message("too-many-format-args", node=node)
elif num_args < required_num_args:
self.add_message("too-few-format-args", node=node)
for arg, format_type in zip(args_elts, required_arg_types):
if not arg:
continue
arg_type = utils.safe_infer(arg)
if (
arg_type
and arg_type != astroid.Uninferable
and not arg_matches_format_type(arg_type, format_type)
):
self.add_message(
"bad-string-format-type",
node=node,
args=(arg_type.pytype(), format_type),
)
@check_messages("f-string-without-interpolation")
def visit_joinedstr(self, node: nodes.JoinedStr) -> None:
self._check_interpolation(node)
def _check_interpolation(self, node: nodes.JoinedStr) -> None:
if isinstance(node.parent, nodes.FormattedValue):
return
for value in node.values:
if isinstance(value, nodes.FormattedValue):
return
self.add_message("f-string-without-interpolation", node=node)
@check_messages(*MSGS)
def visit_call(self, node: nodes.Call) -> None:
func = utils.safe_infer(node.func)
if (
isinstance(func, astroid.BoundMethod)
and isinstance(func.bound, astroid.Instance)
and func.bound.name in {"str", "unicode", "bytes"}
):
if func.name in {"strip", "lstrip", "rstrip"} and node.args:
arg = utils.safe_infer(node.args[0])
if not isinstance(arg, nodes.Const) or not isinstance(arg.value, str):
return
if len(arg.value) != len(set(arg.value)):
self.add_message(
"bad-str-strip-call",
node=node,
args=(func.bound.name, func.name),
)
elif func.name == "format":
self._check_new_format(node, func)
def _detect_vacuous_formatting(self, node, positional_arguments):
counter = collections.Counter(
arg.name for arg in positional_arguments if isinstance(arg, nodes.Name)
)
for name, count in counter.items():
if count == 1:
continue
self.add_message(
"duplicate-string-formatting-argument", node=node, args=(name,)
)
def _check_new_format(self, node, func):
"""Check the new string formatting."""
# Skip format nodes which don't have an explicit string on the
# left side of the format operation.
# We do this because our inference engine can't properly handle
# redefinitions of the original string.
# Note that there may not be any left side at all, if the format method
# has been assigned to another variable. See issue 351. For example:
#
# fmt = 'some string {}'.format
# fmt('arg')
if isinstance(node.func, nodes.Attribute) and not isinstance(
node.func.expr, nodes.Const
):
return
if node.starargs or node.kwargs:
return
try:
strnode = next(func.bound.infer())
except astroid.InferenceError:
return
if not (isinstance(strnode, nodes.Const) and isinstance(strnode.value, str)):
return
try:
call_site = astroid.arguments.CallSite.from_call(node)
except astroid.InferenceError:
return
try:
fields, num_args, manual_pos = utils.parse_format_method_string(
strnode.value
)
except utils.IncompleteFormatString:
self.add_message("bad-format-string", node=node)
return
positional_arguments = call_site.positional_arguments
named_arguments = call_site.keyword_arguments
named_fields = {field[0] for field in fields if isinstance(field[0], str)}
if num_args and manual_pos:
self.add_message("format-combined-specification", node=node)
return
check_args = _False
# Consider "{[0]} {[1]}" as num_args.
num_args += sum(1 for field in named_fields if field == "")
if named_fields:
for field in named_fields:
if field and field not in named_arguments:
self.add_message(
"missing-format-argument-key", node=node, args=(field,)
)
for field in named_arguments:
if field not in named_fields:
self.add_message(
"unused-format-string-argument", node=node, args=(field,)
)
# num_args can be 0 if manual_pos is not.
num_args = num_args or manual_pos
if positional_arguments or num_args:
empty = any(field == "" for field in named_fields)
if named_arguments or empty:
# Verify the required number of positional arguments
# only if the .format got at least one keyword argument.
# This means that the format strings accepts both
# positional and named fields and we should warn
# when one of them is missing or is extra.
check_args = _True
else:
check_args = _True
if check_args:
# num_args can be 0 if manual_pos is not.
num_args = num_args or manual_pos
if not num_args:
self.add_message("format-string-without-interpolation", node=node)
return
if len(positional_arguments) > num_args:
self.add_message("too-many-format-args", node=node)
elif len(positional_arguments) < num_args:
self.add_message("too-few-format-args", node=node)
self._detect_vacuous_formatting(node, positional_arguments)
self._check_new_format_specifiers(node, fields, named_arguments)
def _check_new_format_specifiers(self, node, fields, named):
"""Check attribute and index access in the format
string ("{0.a}" and "{0[a]}").
"""
for key, specifiers in fields:
# Obtain the argument. If it can't be obtained
# or inferred, skip this check.
if key == "":
# {[0]} will have an unnamed argument, defaulting
# to 0. It will not be present in `named`, so use the value
# 0 for it.
key = 0
if isinstance(key, numbers.Number):
try:
argname = utils.get_argument_from_call(node, key)
except utils.NoSuchArgumentError:
continue
else:
if key not in named:
continue
argname = named[key]
if argname in (astroid.Uninferable, None):
continue
try:
argument = utils.safe_infer(argname)
except astroid.InferenceError:
continue
if not specifiers or not argument:
# No need to check this key if it doesn't
# use attribute / item access
continue
if argument.parent and isinstance(argument.parent, nodes.Arguments):
# Ignore any object coming from an argument,
# because we can't infer its value properly.
continue
previous = argument
parsed = []
for is_attribute, specifier in specifiers:
if previous is astroid.Uninferable:
break
parsed.append((is_attribute, specifier))
if is_attribute:
try:
previous = previous.getattr(specifier)[0]
except astroid.NotFoundError:
if (
hasattr(previous, "has_dynamic_getattr")
and previous.has_dynamic_getattr()
):
# Don't warn if the object has a custom __getattr__
break
path = get_access_path(key, parsed)
self.add_message(
"missing-format-attribute",
args=(specifier, path),
node=node,
)
break
else:
warn_error = _False
if hasattr(previous, "getitem"):
try:
previous = previous.getitem(nodes.Const(specifier))
except (
astroid.AstroidIndexError,
astroid.AstroidTypeError,
astroid.AttributeInferenceError,
):
warn_error = _True
except astroid.InferenceError:
break
if previous is astroid.Uninferable:
break
else:
try:
# Lookup __getitem__ in the current node,
# but skip further checks, because we can't
# retrieve the looked object
previous.getattr("__getitem__")
break
except astroid.NotFoundError:
warn_error = _True
if warn_error:
path = get_access_path(key, parsed)
self.add_message(
"invalid-format-index", args=(specifier, path), node=node
)
break
try:
previous = next(previous.infer())
except astroid.InferenceError:
# can't check further if we can't infer it
break
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 296 | parse_format_string | ref | function | ) = utils.parse_format_string(format_string)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 299 | add_message | ref | function | self.add_message(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 306 | add_message | ref | function | self.add_message("truncated-format-string", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 309 | add_message | ref | function | self.add_message("format-string-without-interpolation", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 314 | add_message | ref | function | self.add_message("mixed-format-string", node=node)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 329 | add_message | ref | function | self.add_message(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 341 | add_message | ref | function | self.add_message(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 346 | add_message | ref | function | self.add_message(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 353 | safe_infer | ref | function | arg_type = utils.safe_infer(arg)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/checkers/strings.py | pylint/checkers/strings.py | 358 | arg_matches_format_type | ref | function | and not arg_matches_format_type(arg_type, format_type)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.