AlkantarClanX12
Your IP : 18.116.15.22
# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
"""Checkers for various standard library functions."""
from __future__ import annotations
import sys
from collections.abc import Iterable
from typing import TYPE_CHECKING, Any, Dict, Set, Tuple
import astroid
from astroid import nodes, util
from astroid.typing import InferenceResult
from pylint import interfaces
from pylint.checkers import BaseChecker, DeprecatedMixin, utils
from pylint.interfaces import INFERENCE
from pylint.typing import MessageDefinitionTuple
if TYPE_CHECKING:
from pylint.lint import PyLinter
DeprecationDict = Dict[Tuple[int, int, int], Set[str]]
OPEN_FILES_MODE = ("open", "file")
OPEN_FILES_FUNCS = OPEN_FILES_MODE + ("read_text", "write_text")
UNITTEST_CASE = "unittest.case"
THREADING_THREAD = "threading.Thread"
COPY_COPY = "copy.copy"
OS_ENVIRON = "os._Environ"
ENV_GETTERS = ("os.getenv",)
SUBPROCESS_POPEN = "subprocess.Popen"
SUBPROCESS_RUN = "subprocess.run"
OPEN_MODULE = {"_io", "pathlib"}
DEBUG_BREAKPOINTS = ("builtins.breakpoint", "sys.breakpointhook", "pdb.set_trace")
LRU_CACHE = {
"functools.lru_cache", # Inferred for @lru_cache
"functools._lru_cache_wrapper.wrapper", # Inferred for @lru_cache() on >= Python 3.8
"functools.lru_cache.decorating_function", # Inferred for @lru_cache() on <= Python 3.7
}
NON_INSTANCE_METHODS = {"builtins.staticmethod", "builtins.classmethod"}
# For modules, see ImportsChecker
DEPRECATED_ARGUMENTS: dict[
tuple[int, int, int], dict[str, tuple[tuple[int | None, str], ...]]
] = {
(0, 0, 0): {
"int": ((None, "x"),),
"bool": ((None, "x"),),
"float": ((None, "x"),),
},
(3, 8, 0): {
"asyncio.tasks.sleep": ((None, "loop"),),
"asyncio.tasks.gather": ((None, "loop"),),
"asyncio.tasks.shield": ((None, "loop"),),
"asyncio.tasks.wait_for": ((None, "loop"),),
"asyncio.tasks.wait": ((None, "loop"),),
"asyncio.tasks.as_completed": ((None, "loop"),),
"asyncio.subprocess.create_subprocess_exec": ((None, "loop"),),
"asyncio.subprocess.create_subprocess_shell": ((4, "loop"),),
"gettext.translation": ((5, "codeset"),),
"gettext.install": ((2, "codeset"),),
"functools.partialmethod": ((None, "func"),),
"weakref.finalize": ((None, "func"), (None, "obj")),
"profile.Profile.runcall": ((None, "func"),),
"cProfile.Profile.runcall": ((None, "func"),),
"bdb.Bdb.runcall": ((None, "func"),),
"trace.Trace.runfunc": ((None, "func"),),
"curses.wrapper": ((None, "func"),),
"unittest.case.TestCase.addCleanup": ((None, "function"),),
"concurrent.futures.thread.ThreadPoolExecutor.submit": ((None, "fn"),),
"concurrent.futures.process.ProcessPoolExecutor.submit": ((None, "fn"),),
"contextlib._BaseExitStack.callback": ((None, "callback"),),
"contextlib.AsyncExitStack.push_async_callback": ((None, "callback"),),
"multiprocessing.managers.Server.create": ((None, "c"), (None, "typeid")),
"multiprocessing.managers.SharedMemoryServer.create": (
(None, "c"),
(None, "typeid"),
),
},
(3, 9, 0): {"random.Random.shuffle": ((1, "random"),)},
}
DEPRECATED_DECORATORS: DeprecationDict = {
(3, 8, 0): {"asyncio.coroutine"},
(3, 3, 0): {
"abc.abstractclassmethod",
"abc.abstractstaticmethod",
"abc.abstractproperty",
},
(3, 4, 0): {"importlib.util.module_for_loader"},
}
DEPRECATED_METHODS: dict[int, DeprecationDict] = {
0: {
(0, 0, 0): {
"cgi.parse_qs",
"cgi.parse_qsl",
"ctypes.c_buffer",
"distutils.command.register.register.check_metadata",
"distutils.command.sdist.sdist.check_metadata",
"tkinter.Misc.tk_menuBar",
"tkinter.Menu.tk_bindForTraversal",
}
},
2: {
(2, 6, 0): {
"commands.getstatus",
"os.popen2",
"os.popen3",
"os.popen4",
"macostools.touched",
},
(2, 7, 0): {
"unittest.case.TestCase.assertEquals",
"unittest.case.TestCase.assertNotEquals",
"unittest.case.TestCase.assertAlmostEquals",
"unittest.case.TestCase.assertNotAlmostEquals",
"unittest.case.TestCase.assert_",
"xml.etree.ElementTree.Element.getchildren",
"xml.etree.ElementTree.Element.getiterator",
"xml.etree.ElementTree.XMLParser.getiterator",
"xml.etree.ElementTree.XMLParser.doctype",
},
},
3: {
(3, 0, 0): {
"inspect.getargspec",
"failUnlessEqual",
"assertEquals",
"failIfEqual",
"assertNotEquals",
"failUnlessAlmostEqual",
"assertAlmostEquals",
"failIfAlmostEqual",
"assertNotAlmostEquals",
"failUnless",
"assert_",
"failUnlessRaises",
"failIf",
"assertRaisesRegexp",
"assertRegexpMatches",
"assertNotRegexpMatches",
},
(3, 1, 0): {
"base64.encodestring",
"base64.decodestring",
"ntpath.splitunc",
"os.path.splitunc",
"os.stat_float_times",
"turtle.RawTurtle.settiltangle",
},
(3, 2, 0): {
"cgi.escape",
"configparser.RawConfigParser.readfp",
"xml.etree.ElementTree.Element.getchildren",
"xml.etree.ElementTree.Element.getiterator",
"xml.etree.ElementTree.XMLParser.getiterator",
"xml.etree.ElementTree.XMLParser.doctype",
},
(3, 3, 0): {
"inspect.getmoduleinfo",
"logging.warn",
"logging.Logger.warn",
"logging.LoggerAdapter.warn",
"nntplib._NNTPBase.xpath",
"platform.popen",
"sqlite3.OptimizedUnicode",
"time.clock",
},
(3, 4, 0): {
"importlib.find_loader",
"importlib.abc.Loader.load_module",
"importlib.abc.Loader.module_repr",
"importlib.abc.PathEntryFinder.find_loader",
"importlib.abc.PathEntryFinder.find_module",
"plistlib.readPlist",
"plistlib.writePlist",
"plistlib.readPlistFromBytes",
"plistlib.writePlistToBytes",
},
(3, 4, 4): {"asyncio.tasks.async"},
(3, 5, 0): {
"fractions.gcd",
"inspect.formatargspec",
"inspect.getcallargs",
"platform.linux_distribution",
"platform.dist",
},
(3, 6, 0): {
"importlib._bootstrap_external.FileLoader.load_module",
"_ssl.RAND_pseudo_bytes",
},
(3, 7, 0): {
"sys.set_coroutine_wrapper",
"sys.get_coroutine_wrapper",
"aifc.openfp",
"threading.Thread.isAlive",
"asyncio.Task.current_task",
"asyncio.Task.all_task",
"locale.format",
"ssl.wrap_socket",
"ssl.match_hostname",
"sunau.openfp",
"wave.openfp",
},
(3, 8, 0): {
"gettext.lgettext",
"gettext.ldgettext",
"gettext.lngettext",
"gettext.ldngettext",
"gettext.bind_textdomain_codeset",
"gettext.NullTranslations.output_charset",
"gettext.NullTranslations.set_output_charset",
"threading.Thread.isAlive",
},
(3, 9, 0): {
"binascii.b2a_hqx",
"binascii.a2b_hqx",
"binascii.rlecode_hqx",
"binascii.rledecode_hqx",
},
(3, 10, 0): {
"_sqlite3.enable_shared_cache",
"importlib.abc.Finder.find_module",
"pathlib.Path.link_to",
"zipimport.zipimporter.load_module",
"zipimport.zipimporter.find_module",
"zipimport.zipimporter.find_loader",
"threading.currentThread",
"threading.activeCount",
"threading.Condition.notifyAll",
"threading.Event.isSet",
"threading.Thread.setName",
"threading.Thread.getName",
"threading.Thread.isDaemon",
"threading.Thread.setDaemon",
"cgi.log",
},
(3, 11, 0): {
"locale.getdefaultlocale",
"locale.resetlocale",
"re.template",
"unittest.findTestCases",
"unittest.makeSuite",
"unittest.getTestCaseNames",
"unittest.TestLoader.loadTestsFromModule",
"unittest.TestLoader.loadTestsFromTestCase",
"unittest.TestLoader.getTestCaseNames",
},
},
}
DEPRECATED_CLASSES: dict[tuple[int, int, int], dict[str, set[str]]] = {
(3, 2, 0): {
"configparser": {
"LegacyInterpolation",
"SafeConfigParser",
},
},
(3, 3, 0): {
"importlib.abc": {
"Finder",
},
"pkgutil": {
"ImpImporter",
"ImpLoader",
},
"collections": {
"Awaitable",
"Coroutine",
"AsyncIterable",
"AsyncIterator",
"AsyncGenerator",
"Hashable",
"Iterable",
"Iterator",
"Generator",
"Reversible",
"Sized",
"Container",
"Callable",
"Collection",
"Set",
"MutableSet",
"Mapping",
"MutableMapping",
"MappingView",
"KeysView",
"ItemsView",
"ValuesView",
"Sequence",
"MutableSequence",
"ByteString",
},
},
(3, 9, 0): {
"smtpd": {
"MailmanProxy",
}
},
(3, 11, 0): {
"typing": {
"Text",
},
"webbrowser": {
"MacOSX",
},
},
}
def _check_mode_str(mode: Any) -> bool:
# check type
if not isinstance(mode, str):
return False
# check syntax
modes = set(mode)
_mode = "rwatb+Ux"
creating = "x" in modes
if modes - set(_mode) or len(mode) > len(modes):
return False
# check logic
reading = "r" in modes
writing = "w" in modes
appending = "a" in modes
text = "t" in modes
binary = "b" in modes
if "U" in modes:
if writing or appending or creating:
return False
reading = True
if text and binary:
return False
total = reading + writing + appending + creating
if total > 1:
return False
if not (reading or writing or appending or creating):
return False
return True
class StdlibChecker(DeprecatedMixin, BaseChecker):
name = "stdlib"
msgs: dict[str, MessageDefinitionTuple] = {
**DeprecatedMixin.DEPRECATED_METHOD_MESSAGE,
**DeprecatedMixin.DEPRECATED_ARGUMENT_MESSAGE,
**DeprecatedMixin.DEPRECATED_CLASS_MESSAGE,
**DeprecatedMixin.DEPRECATED_DECORATOR_MESSAGE,
"W1501": (
'"%s" is not a valid mode for open.',
"bad-open-mode",
"Python supports: r, w, a[, x] modes with b, +, "
"and U (only with r) options. "
"See https://docs.python.org/3/library/functions.html#open",
),
"W1502": (
"Using datetime.time in a boolean context.",
"boolean-datetime",
"Using datetime.time in a boolean context can hide "
"subtle bugs when the time they represent matches "
"midnight UTC. This behaviour was fixed in Python 3.5. "
"See https://bugs.python.org/issue13936 for reference.",
{"maxversion": (3, 5)},
),
"W1503": (
"Redundant use of %s with constant value %r",
"redundant-unittest-assert",
"The first argument of assertTrue and assertFalse is "
"a condition. If a constant is passed as parameter, that "
"condition will be always true. In this case a warning "
"should be emitted.",
),
"W1506": (
"threading.Thread needs the target function",
"bad-thread-instantiation",
"The warning is emitted when a threading.Thread class "
"is instantiated without the target function being passed as a kwarg or as a second argument. "
"By default, the first parameter is the group param, not the target param.",
),
"W1507": (
"Using copy.copy(os.environ). Use os.environ.copy() instead.",
"shallow-copy-environ",
"os.environ is not a dict object but proxy object, so "
"shallow copy has still effects on original object. "
"See https://bugs.python.org/issue15373 for reference.",
),
"E1507": (
"%s does not support %s type argument",
"invalid-envvar-value",
"Env manipulation functions support only string type arguments. "
"See https://docs.python.org/3/library/os.html#os.getenv.",
),
"E1519": (
"singledispatch decorator should not be used with methods, "
"use singledispatchmethod instead.",
"singledispatch-method",
"singledispatch should decorate functions and not class/instance methods. "
"Use singledispatchmethod for those cases.",
),
"E1520": (
"singledispatchmethod decorator should not be used with functions, "
"use singledispatch instead.",
"singledispatchmethod-function",
"singledispatchmethod should decorate class/instance methods and not functions. "
"Use singledispatch for those cases.",
),
"W1508": (
"%s default type is %s. Expected str or None.",
"invalid-envvar-default",
"Env manipulation functions return None or str values. "
"Supplying anything different as a default may cause bugs. "
"See https://docs.python.org/3/library/os.html#os.getenv.",
),
"W1509": (
"Using preexec_fn keyword which may be unsafe in the presence "
"of threads",
"subprocess-popen-preexec-fn",
"The preexec_fn parameter is not safe to use in the presence "
"of threads in your application. The child process could "
"deadlock before exec is called. If you must use it, keep it "
"trivial! Minimize the number of libraries you call into. "
"See https://docs.python.org/3/library/subprocess.html#popen-constructor",
),
"W1510": (
"'subprocess.run' used without explicitly defining the value for 'check'.",
"subprocess-run-check",
"The ``check`` keyword is set to False by default. It means the process "
"launched by ``subprocess.run`` can exit with a non-zero exit code and "
"fail silently. It's better to set it explicitly to make clear what the "
"error-handling behavior is.",
),
"W1514": (
"Using open without explicitly specifying an encoding",
"unspecified-encoding",
"It is better to specify an encoding when opening documents. "
"Using the system default implicitly can create problems on other operating systems. "
"See https://peps.python.org/pep-0597/",
),
"W1515": (
"Leaving functions creating breakpoints in production code is not recommended",
"forgotten-debug-statement",
"Calls to breakpoint(), sys.breakpointhook() and pdb.set_trace() should be removed "
"from code that is not actively being debugged.",
),
"W1518": (
"'lru_cache(maxsize=None)' or 'cache' will keep all method args alive indefinitely, including 'self'",
"method-cache-max-size-none",
"By decorating a method with lru_cache or cache the 'self' argument will be linked to "
"the function and therefore never garbage collected. Unless your instance "
"will never need to be garbage collected (singleton) it is recommended to refactor "
"code to avoid this pattern or add a maxsize to the cache. "
"The default value for maxsize is 128.",
{
"old_names": [
("W1516", "lru-cache-decorating-method"),
("W1517", "cache-max-size-none"),
]
},
),
}
def __init__(self, linter: PyLinter) -> None:
BaseChecker.__init__(self, linter)
self._deprecated_methods: set[str] = set()
self._deprecated_arguments: dict[str, tuple[tuple[int | None, str], ...]] = {}
self._deprecated_classes: dict[str, set[str]] = {}
self._deprecated_decorators: set[str] = set()
for since_vers, func_list in DEPRECATED_METHODS[sys.version_info[0]].items():
if since_vers <= sys.version_info:
self._deprecated_methods.update(func_list)
for since_vers, args_list in DEPRECATED_ARGUMENTS.items():
if since_vers <= sys.version_info:
self._deprecated_arguments.update(args_list)
for since_vers, class_list in DEPRECATED_CLASSES.items():
if since_vers <= sys.version_info:
self._deprecated_classes.update(class_list)
for since_vers, decorator_list in DEPRECATED_DECORATORS.items():
if since_vers <= sys.version_info:
self._deprecated_decorators.update(decorator_list)
# Modules are checked by the ImportsChecker, because the list is
# synced with the config argument deprecated-modules
def _check_bad_thread_instantiation(self, node: nodes.Call) -> None:
func_kwargs = {key.arg for key in node.keywords}
if "target" in func_kwargs:
return
if len(node.args) < 2 and (not node.kwargs or "target" not in func_kwargs):
self.add_message(
"bad-thread-instantiation", node=node, confidence=interfaces.HIGH
)
def _check_for_preexec_fn_in_popen(self, node: nodes.Call) -> None:
if node.keywords:
for keyword in node.keywords:
if keyword.arg == "preexec_fn":
self.add_message("subprocess-popen-preexec-fn", node=node)
def _check_for_check_kw_in_run(self, node: nodes.Call) -> None:
kwargs = {keyword.arg for keyword in (node.keywords or ())}
if "check" not in kwargs:
self.add_message("subprocess-run-check", node=node, confidence=INFERENCE)
def _check_shallow_copy_environ(self, node: nodes.Call) -> None:
arg = utils.get_argument_from_call(node, position=0)
try:
inferred_args = arg.inferred()
except astroid.InferenceError:
return
for inferred in inferred_args:
if inferred.qname() == OS_ENVIRON:
self.add_message("shallow-copy-environ", node=node)
break
@utils.only_required_for_messages(
"bad-open-mode",
"redundant-unittest-assert",
"deprecated-method",
"deprecated-argument",
"bad-thread-instantiation",
"shallow-copy-environ",
"invalid-envvar-value",
"invalid-envvar-default",
"subprocess-popen-preexec-fn",
"subprocess-run-check",
"deprecated-class",
"unspecified-encoding",
"forgotten-debug-statement",
)
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 isinstance(inferred, util.UninferableBase):
continue
if inferred.root().name in OPEN_MODULE:
open_func_name: str | None = None
if isinstance(node.func, nodes.Name):
open_func_name = node.func.name
if isinstance(node.func, nodes.Attribute):
open_func_name = node.func.attrname
if open_func_name in OPEN_FILES_FUNCS:
self._check_open_call(node, inferred.root().name, open_func_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.only_required_for_messages("boolean-datetime")
def visit_unaryop(self, node: nodes.UnaryOp) -> None:
if node.op == "not":
self._check_datetime(node.operand)
@utils.only_required_for_messages("boolean-datetime")
def visit_if(self, node: nodes.If) -> None:
self._check_datetime(node.test)
@utils.only_required_for_messages("boolean-datetime")
def visit_ifexp(self, node: nodes.IfExp) -> None:
self._check_datetime(node.test)
@utils.only_required_for_messages("boolean-datetime")
def visit_boolop(self, node: nodes.BoolOp) -> None:
for value in node.values:
self._check_datetime(value)
@utils.only_required_for_messages(
"method-cache-max-size-none",
"singledispatch-method",
"singledispatchmethod-function",
)
def visit_functiondef(self, node: nodes.FunctionDef) -> None:
if node.decorators and isinstance(node.parent, nodes.ClassDef):
self._check_lru_cache_decorators(node)
self._check_dispatch_decorators(node)
def _check_lru_cache_decorators(self, node: nodes.FunctionDef) -> None:
"""Check if instance methods are decorated with functools.lru_cache."""
if any(utils.is_enum(ancestor) for ancestor in node.parent.ancestors()):
# method of class inheriting from Enum is exempt from this check.
return
lru_cache_nodes: list[nodes.NodeNG] = []
for d_node in node.decorators.nodes:
# pylint: disable = too-many-try-statements
try:
for infered_node in d_node.infer():
q_name = infered_node.qname()
if q_name in NON_INSTANCE_METHODS:
return
# Check if there is a maxsize argument set to None in the call
if q_name in LRU_CACHE and isinstance(d_node, nodes.Call):
try:
arg = utils.get_argument_from_call(
d_node, position=0, keyword="maxsize"
)
except utils.NoSuchArgumentError:
break
if not isinstance(arg, nodes.Const) or arg.value is not None:
break
lru_cache_nodes.append(d_node)
break
if q_name == "functools.cache":
lru_cache_nodes.append(d_node)
break
except astroid.InferenceError:
pass
for lru_cache_node in lru_cache_nodes:
self.add_message(
"method-cache-max-size-none",
node=lru_cache_node,
confidence=interfaces.INFERENCE,
)
def _check_dispatch_decorators(self, node: nodes.FunctionDef) -> None:
decorators_map: dict[str, tuple[nodes.NodeNG, interfaces.Confidence]] = {}
for decorator in node.decorators.nodes:
if isinstance(decorator, nodes.Name) and decorator.name:
decorators_map[decorator.name] = (decorator, interfaces.HIGH)
elif utils.is_registered_in_singledispatch_function(node):
decorators_map["singledispatch"] = (decorator, interfaces.INFERENCE)
elif utils.is_registered_in_singledispatchmethod_function(node):
decorators_map["singledispatchmethod"] = (
decorator,
interfaces.INFERENCE,
)
if "singledispatch" in decorators_map and "classmethod" in decorators_map:
self.add_message(
"singledispatch-method",
node=decorators_map["singledispatch"][0],
confidence=decorators_map["singledispatch"][1],
)
elif (
"singledispatchmethod" in decorators_map
and "staticmethod" in decorators_map
):
self.add_message(
"singledispatchmethod-function",
node=decorators_map["singledispatchmethod"][0],
confidence=decorators_map["singledispatchmethod"][1],
)
def _check_redundant_assert(self, node: nodes.Call, infer: InferenceResult) -> None:
if (
isinstance(infer, astroid.BoundMethod)
and node.args
and isinstance(node.args[0], nodes.Const)
and infer.name in {"assertTrue", "assertFalse"}
):
self.add_message(
"redundant-unittest-assert",
args=(infer.name, node.args[0].value),
node=node,
)
def _check_datetime(self, node: nodes.NodeNG) -> None:
"""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_call(
self, node: nodes.Call, open_module: str, func_name: str
) -> None:
"""Various checks for an open call."""
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 (
func_name in OPEN_FILES_MODE
and 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),
)
if (
not mode_arg
or isinstance(mode_arg, nodes.Const)
and (not mode_arg.value or "b" not in str(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: nodes.Call, infer: nodes.FunctionDef) -> None:
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: nodes.Call,
infer: nodes.FunctionDef,
message: str,
call_arg: InferenceResult | None,
allow_none: bool,
) -> None:
if call_arg is None or isinstance(call_arg, util.UninferableBase):
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_methods(self) -> set[str]:
return self._deprecated_methods
def deprecated_arguments(self, method: str) -> tuple[tuple[int | None, str], ...]:
return self._deprecated_arguments.get(method, ())
def deprecated_classes(self, module: str) -> Iterable[str]:
return self._deprecated_classes.get(module, ())
def deprecated_decorators(self) -> Iterable[str]:
return self._deprecated_decorators
def register(linter: PyLinter) -> None:
linter.register_checker(StdlibChecker(linter))