eric: comparison src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Miscellaneous/MiscellaneousChecker.py

-:fc45672fae42
+:73d80859079c
 import ast
 import builtins
 import contextlib
 import copy
 import itertools
-import math
 import re
 import sys
 import tokenize
-from collections import Counter, defaultdict, namedtuple
-from dataclasses import dataclass
-from keyword import iskeyword
 from string import Formatter
 try:
 # Python 3.10+
 from itertools import pairwise
 return zip(a, b)
 import AstUtilities
+from CodeStyleTopicChecker import CodeStyleTopicChecker
+from .BugBearVisitor import BugBearVisitor
+from .DateTimeVisitor import DateTimeVisitor
+from .DefaultMatchCaseVisitor import DefaultMatchCaseVisitor
 from .eradicate import Eradicator
 from .MiscellaneousDefaults import MiscellaneousCheckerDefaultArgs
+from .ReturnVisitor import ReturnVisitor
-BugbearMutableLiterals = ("Dict", "List", "Set")
+from .SysVersionVisitor import SysVersionVisitor
-BugbearMutableComprehensions = ("ListComp", "DictComp", "SetComp")
+from .TextVisitor import TextVisitor
-BugbearMutableCalls = (
-"Counter",
-"OrderedDict",
+class MiscellaneousChecker(CodeStyleTopicChecker):
-"collections.Counter",
-"collections.OrderedDict",
-"collections.defaultdict",
-"collections.deque",
-"defaultdict",
-"deque",
-"dict",
-"list",
-"set",
-)
-BugbearImmutableCalls = (
-"tuple",
-"frozenset",
-"types.MappingProxyType",
-"MappingProxyType",
-"re.compile",
-"operator.attrgetter",
-"operator.itemgetter",
-"operator.methodcaller",
-"attrgetter",
-"itemgetter",
-"methodcaller",
-)
-def composeCallPath(node):
-"""
-Generator function to assemble the call path of a given node.
-@param node node to assemble call path for
-@type ast.Node
-@yield call path components
-@ytype str
-"""
-if isinstance(node, ast.Attribute):
-yield from composeCallPath(node.value)
-yield node.attr
-elif isinstance(node, ast.Call):
-yield from composeCallPath(node.func)
-elif isinstance(node, ast.Name):
-yield node.id
-class MiscellaneousChecker:
 """
 Class implementing a checker for miscellaneous checks.
 """
 Codes = [
 "M-711",
 ## print() statements
 "M-801",
 ## one element tuple
 "M-811",
-## return statements
+## return statements  # noqa: M-891
 "M-831",
 "M-832",
 "M-833",
 "M-834",
 ## line continuation
 "M-891",
 ## structural pattern matching
 "M-901",
 "M-902",
 ]
+Category = "M"
 Formatter = Formatter()
 FormatFieldRegex = re.compile(r"^((?:\s|.)*?)(\..*|\[.*\])?$")
 BuiltinsWhiteList = [
 @param repeat flag indicating to report each occurrence of a code
 @type bool
 @param args dictionary of arguments for the miscellaneous checks
 @type dict
 """
-self.__select = tuple(select)
+super().__init__(
-self.__ignore = tuple(ignore)
+MiscellaneousChecker.Category,
-self.__expected = expected[:]
+source,
-self.__repeat = repeat
+filename,
-self.__filename = filename
+tree,
-self.__source = source[:]
+select,
-self.__tree = copy.deepcopy(tree)
+ignore,
-self.__args = args
+expected,
+repeat,
-linesIterator = iter(self.__source)
+args,
+)
+linesIterator = iter(self.source)
 self.__tokens = list(tokenize.generate_tokens(lambda: next(linesIterator)))
 self.__pep3101FormatRegex = re.compile(
 r'^(?:[^\'"]*[\'"][^\'"]*[\'"])*\s*%|^\s*%'
 )
 self.__builtins = [b for b in dir(builtins) if b not in self.BuiltinsWhiteList]
 self.__eradicator = Eradicator()
-# statistics counters
-self.counters = {}
-# collection of detected errors
-self.errors = []
 checkersWithCodes = [
 (self.__checkCoding, ("M-101", "M-102")),
 (self.__checkCopyright, ("M-111", "M-112")),
 (self.__checkBuiltins, ("M-131", "M-132")),
 (self.__checkImplicitStringConcat, ("M-851", "M-852")),
 (self.__checkExplicitStringConcat, ("M-853",)),
 (self.__checkCommentedCode, ("M-891",)),
 (self.__checkDefaultMatchCase, ("M-901", "M-902")),
 ]
+self._initializeCheckers(checkersWithCodes)
 # the eradicate whitelist
-commentedCodeCheckerArgs = self.__args.get(
+commentedCodeCheckerArgs = self.args.get(
 "CommentedCodeChecker",
 MiscellaneousCheckerDefaultArgs["CommentedCodeChecker"],
 )
 commentedCodeCheckerWhitelist = commentedCodeCheckerArgs.get(
 "WhiteList",
 )
 self.__eradicator.update_whitelist(
 commentedCodeCheckerWhitelist, extend_default=False
 )
-self.__checkers = []
-for checker, codes in checkersWithCodes:
-if any(not (code and self.__ignoreCode(code)) for code in codes):
-self.__checkers.append(checker)
-def __ignoreCode(self, code):
-"""
-Private method to check if the message code should be ignored.
-@param code message code to check for
-@type str
-@return flag indicating to ignore the given code
-@rtype bool
-"""
-return code in self.__ignore or (
-code.startswith(self.__ignore) and not code.startswith(self.__select)
-)
-def __error(self, lineNumber, offset, code, *args):
-"""
-Private method to record an issue.
-@param lineNumber line number of the issue
-@type int
-@param offset position within line of the issue
-@type int
-@param code message code
-@type str
-@param args arguments for the message
-@type list
-"""
-if self.__ignoreCode(code):
-return
-if code in self.counters:
-self.counters[code] += 1
-else:
-self.counters[code] = 1
-# Don't care about expected codes
-if code in self.__expected:
-return
-if code and (self.counters[code] == 1 or self.__repeat):
-# record the issue with one based line number
-self.errors.append(
-{
-"file": self.__filename,
-"line": lineNumber + 1,
-"offset": offset,
-"code": code,
-"args": args,
-}
-)
-def run(self):
-"""
-Public method to check the given source against miscellaneous
-conditions.
-"""
-if not self.__filename:
-# don't do anything, if essential data is missing
-return
-if not self.__checkers:
-# don't do anything, if no codes were selected
-return
-for check in self.__checkers:
-check()
 def __getCoding(self):
 """
 Private method to get the defined coding of the source.
 @return tuple containing the line number and the coding
 @rtype tuple of int and str
 """
-for lineno, line in enumerate(self.__source[:5]):
+for lineno, line in enumerate(self.source[:5], start=1):
 matched = re.search(r"coding[:=]\s*([-\w_.]+)", line, re.IGNORECASE)
 if matched:
 return lineno, matched.group(1)
 else:
 return 0, ""
 def __checkCoding(self):
 """
 Private method to check the presence of a coding line and valid
 encodings.
 """
-if len(self.__source) == 0:
+if len(self.source) == 0:
 return
 encodings = [
 e.lower().strip()
-for e in self.__args.get(
+for e in self.args.get(
 "CodingChecker", MiscellaneousCheckerDefaultArgs["CodingChecker"]
 ).split(",")
 ]
 lineno, coding = self.__getCoding()
 if coding:
 if coding.lower() not in encodings:
-self.__error(lineno, 0, "M-102", coding)
+self.addError(lineno, 0, "M-102", coding)
 else:
-self.__error(0, 0, "M-101")
+self.addError(1, 0, "M-101")
 def __checkCopyright(self):
 """
 Private method to check the presence of a copyright statement.
 """
-source = "".join(self.__source)
+source = "".join(self.source)
-copyrightArgs = self.__args.get(
+copyrightArgs = self.args.get(
 "CopyrightChecker", MiscellaneousCheckerDefaultArgs["CopyrightChecker"]
 )
 copyrightMinFileSize = copyrightArgs.get(
 "MinFilesize",
 MiscellaneousCheckerDefaultArgs["CopyrightChecker"]["MinFilesize"],
 if len(topOfSource) < copyrightMinFileSize:
 return
 copyrightRe = re.compile(copyrightRegexStr.format(author=r".*"), re.IGNORECASE)
 if not copyrightRe.search(topOfSource):
-self.__error(0, 0, "M-111")
+self.addError(1, 0, "M-111")
 return
 if copyrightAuthor:
 copyrightAuthorRe = re.compile(
 copyrightRegexStr.format(author=copyrightAuthor), re.IGNORECASE
 )
 if not copyrightAuthorRe.search(topOfSource):
-self.__error(0, 0, "M-112")
+self.addError(1, 0, "M-112")
 def __checkCommentedCode(self):
 """
 Private method to check for commented code.
 """
-source = "".join(self.__source)
+source = "".join(self.source)
-commentedCodeCheckerArgs = self.__args.get(
+commentedCodeCheckerArgs = self.args.get(
 "CommentedCodeChecker",
 MiscellaneousCheckerDefaultArgs["CommentedCodeChecker"],
 )
 aggressive = commentedCodeCheckerArgs.get(
 "Aggressive",
 MiscellaneousCheckerDefaultArgs["CommentedCodeChecker"]["Aggressive"],
 )
 for markedLine in self.__eradicator.commented_out_code_line_numbers(
 source, aggressive=aggressive
 ):
-self.__error(markedLine - 1, 0, "M-891")
+self.addError(markedLine, 0, "M-891")
 def __checkLineContinuation(self):
 """
 Private method to check line continuation using backslash.
 """
 # generate source lines without comments
 comments = [tok for tok in self.__tokens if tok[0] == tokenize.COMMENT]
-stripped = self.__source[:]
+stripped = self.source[:]
 for comment in comments:
 lineno = comment[3][0]
 start = comment[2][1]
 stop = comment[3][1]
 content = stripped[lineno - 1]
 for lineIndex, line in enumerate(stripped):
 strippedLine = line.strip()
 if strippedLine.endswith("\\") and not strippedLine.startswith(
 ("assert", "with")
 ):
-self.__error(lineIndex, len(line), "M-841")
+self.addError(lineIndex + 1, len(line), "M-841")
 def __checkPrintStatements(self):
 """
 Private method to check for print statements.
 """
-for node in ast.walk(self.__tree):
+for node in ast.walk(self.tree):
 if (
 isinstance(node, ast.Call) and getattr(node.func, "id", None) == "print"
 ) or (hasattr(ast, "Print") and isinstance(node, ast.Print)):
-self.__error(node.lineno - 1, node.col_offset, "M-801")
+self.addErrorFromNode(node, "M-801")
 def __checkTuple(self):
 """
 Private method to check for one element tuples.
 """
-for node in ast.walk(self.__tree):
+for node in ast.walk(self.tree):
 if isinstance(node, ast.Tuple) and len(node.elts) == 1:
-self.__error(node.lineno - 1, node.col_offset, "M-811")
+self.addErrorFromNode(node, "M-811")
 def __checkFuture(self):
 """
 Private method to check the __future__ imports.
 """
 expectedImports = {
 i.strip()
-for i in self.__args.get("FutureChecker", "").split(",")
+for i in self.args.get("FutureChecker", "").split(",")
 if bool(i.strip())
 }
 if len(expectedImports) == 0:
 # nothing to check for; disabling the check
 return
 imports = set()
 node = None
 hasCode = False
-for node in ast.walk(self.__tree):
+for node in ast.walk(self.tree):
 if isinstance(node, ast.ImportFrom) and node.module == "__future__":
 imports |= {name.name for name in node.names}
 elif isinstance(node, ast.Expr):
 if not AstUtilities.isString(node.value):
 hasCode = True
 if isinstance(node, ast.Module) or not hasCode:
 return
 if imports < expectedImports:
 if imports:
-self.__error(
+self.addErrorFromNode(
-node.lineno - 1,
+node, "M-701", ", ".join(expectedImports), ", ".join(imports)
-node.col_offset,
-"M-701",
-", ".join(expectedImports),
-", ".join(imports),
 )
 else:
-self.__error(
+self.addErrorFromNode(node, "M-702", ", ".join(expectedImports))
-node.lineno - 1,
-node.col_offset,
-"M-702",
-", ".join(expectedImports),
-)
 def __checkPep3101(self):
 """
 Private method to check for old style string formatting.
 """
-for lineno, line in enumerate(self.__source):
+for lineno, line in enumerate(self.source, start=1):
 match = self.__pep3101FormatRegex.search(line)
 if match:
 lineLen = len(line)
 pos = line.find("%")
 formatPos = pos
 if pos >= lineLen:
 break
 c = line[pos]
 if c in "diouxXeEfFgGcrs":
 formatter += c
-self.__error(lineno, formatPos, "M-601", formatter)
+self.addError(lineno, formatPos, "M-601", formatter)
 def __checkFormatString(self):
 """
 Private method to check string format strings.
 """
 if not coding:
 # default to utf-8
 coding = "utf-8"
 visitor = TextVisitor()
-visitor.visit(self.__tree)
+visitor.visit(self.tree)
 for node in visitor.nodes:
 text = node.value
 if isinstance(text, bytes):
 try:
 text = text.decode(coding)
 except UnicodeDecodeError:
 continue
 fields, implicit, explicit = self.__getFields(text)
 if implicit:
 if node in visitor.calls:
-self.__error(node.lineno - 1, node.col_offset, "M-611")
+self.addErrorFromNode(node, "M-611")
 else:
 if node.is_docstring:
-self.__error(node.lineno - 1, node.col_offset, "M-612")
+self.addErrorFromNode(node, "M-612")
 else:
-self.__error(node.lineno - 1, node.col_offset, "M-613")
+self.addErrorFromNode(node, "M-613")
 if node in visitor.calls:
 call, strArgs = visitor.calls[node]
 numbers = set()
 if number >= 0:
 numbers.add(number)
 else:
 names.add(fieldMatch.group(1))
-keywords = {keyword.arg for keyword in call.keywords}
+keywords = {kw.arg for kw in call.keywords}
 numArgs = len(call.args)
 if strArgs:
 numArgs -= 1
 hasKwArgs = any(kw.arg is None for kw in call.keywords)
 hasStarArgs = sum(
 # if starargs or kwargs is not None, it can't count the
 # parameters but at least check if the args are used
 if hasKwArgs and not names:
 # No names but kwargs
-self.__error(call.lineno - 1, call.col_offset, "M-623")
+self.addErrorFromNode(call, "M-623")
 if hasStarArgs and not numbers:
 # No numbers but args
-self.__error(call.lineno - 1, call.col_offset, "M-624")
+self.addErrorFromNode(call, "M-624")
 if not hasKwArgs and not hasStarArgs:
 # can actually verify numbers and names
 for number in sorted(numbers):
 if number >= numArgs:
-self.__error(
+self.addErrorFromNode(call, "M-621", number)
-call.lineno - 1, call.col_offset, "M-621", number
-)
 for name in sorted(names):
 if name not in keywords:
-self.__error(
+self.addErrorFromNode(call, "M-622", name)
-call.lineno - 1, call.col_offset, "M-622", name
-)
 for arg in range(numArgs):
 if arg not in numbers:
-self.__error(call.lineno - 1, call.col_offset, "M-631", arg)
+self.addErrorFromNode(call, "M-631", arg)
-for keyword in keywords:
+for kw in keywords:
-if keyword not in names:
+if kw not in names:
-self.__error(call.lineno - 1, call.col_offset, "M-632", keyword)
+self.addErrorFromNode(call, "M-632", kw)
 if implicit and explicit:
-self.__error(call.lineno - 1, call.col_offset, "M-625")
+self.addErrorFromNode(call, "M-625")
 def __getFields(self, string):
 """
 Private method to extract the format field information.
 """
 functionDefs = [ast.FunctionDef]
 with contextlib.suppress(AttributeError):
 functionDefs.append(ast.AsyncFunctionDef)
-ignoreBuiltinAssignments = self.__args.get(
+ignoreBuiltinAssignments = self.args.get(
 "BuiltinsChecker", MiscellaneousCheckerDefaultArgs["BuiltinsChecker"]
 )
-for node in ast.walk(self.__tree):
+for node in ast.walk(self.tree):
 if isinstance(node, ast.Assign):
 # assign statement
 for element in node.targets:
 if isinstance(element, ast.Name) and element.id in self.__builtins:
 value = node.value
 and element.id in ignoreBuiltinAssignments
 and value.id in ignoreBuiltinAssignments[element.id]
 ):
 # ignore compatibility assignments
 continue
-self.__error(
+self.addErrorFromNode(element, "M-131", element.id)
-element.lineno - 1, element.col_offset, "M-131", element.id
-)
 elif isinstance(element, (ast.Tuple, ast.List)):
 for tupleElement in element.elts:
 if (
 isinstance(tupleElement, ast.Name)
 and tupleElement.id in self.__builtins
 ):
-self.__error(
+self.addErrorFromNode(
-tupleElement.lineno - 1,
+tupleElement, "M-131", tupleElement.id
-tupleElement.col_offset,
-"M-131",
-tupleElement.id,
 )
 elif isinstance(node, ast.For):
 # for loop
 target = node.target
 if isinstance(target, ast.Name) and target.id in self.__builtins:
-self.__error(
+self.addErrorFromNode(target, "M-131", target.id)
-target.lineno - 1, target.col_offset, "M-131", target.id
-)
 elif isinstance(target, (ast.Tuple, ast.List)):
 for element in target.elts:
 if (
 isinstance(element, ast.Name)
 and element.id in self.__builtins
 ):
-self.__error(
+self.addErrorFromNode(element, "M-131", element.id)
-element.lineno - 1,
-element.col_offset,
-"M-131",
-element.id,
-)
 elif any(isinstance(node, functionDef) for functionDef in functionDefs):
 # (asynchronous) function definition
 for arg in node.args.args:
 if isinstance(arg, ast.arg) and arg.arg in self.__builtins:
-self.__error(arg.lineno - 1, arg.col_offset, "M-132", arg.arg)
+self.addErrorFromNode(arg, "M-132", arg.arg)
 def __checkComprehensions(self):
 """
 Private method to check some comprehension related things.
 ast.SetComp: "set",
 }
 visitedMapCalls = set()
-for node in ast.walk(self.__tree):
+for node in ast.walk(self.tree):
 if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
 numPositionalArgs = len(node.args)
 numKeywordArgs = len(node.keywords)
 if (
 ):
 errorCode = {
 "list": "M-180",
 "set": "M-181",
 }[node.func.id]
-self.__error(node.lineno - 1, node.col_offset, errorCode)
+self.addErrorFromNode(node, errorCode)
 elif (
 numPositionalArgs == 1
 and node.func.id == "dict"
 and len(node.keywords) == 0
 ):
 if isinstance(node.args[0], ast.GeneratorExp):
 errorCode = "M-182"
 else:
 errorCode = "M-184"
-self.__error(node.lineno - 1, node.col_offset, errorCode)
+self.addErrorFromNode(node, errorCode)
 elif (
 numPositionalArgs == 1
 and isinstance(node.args[0], ast.ListComp)
 and node.func.id in ("list", "set", "any", "all")
 "list": "M-191",
 "set": "M-183",
 "any": "M-199",
 "all": "M-199",
 }[node.func.id]
-self.__error(
+self.addErrorFromNode(node, errorCode, node.func.id)
-node.lineno - 1, node.col_offset, errorCode, node.func.id
-)
 elif numPositionalArgs == 1 and (
 isinstance(node.args[0], ast.Tuple)
 and node.func.id == "tuple"
 or isinstance(node.args[0], ast.List)
 ):
 errorCode = {
 "tuple": "M-189a",
 "list": "M-190a",
 }[node.func.id]
-self.__error(
+self.addErrorFromNode(
-node.lineno - 1,
+node,
-node.col_offset,
 errorCode,
 type(node.args[0]).__name__.lower(),
 node.func.id,
 )
 ):
 if isinstance(node.args[0], ast.Dict):
 type_ = "dict"
 else:
 type_ = "dict comprehension"
-self.__error(
+self.addErrorFromNode(node, "M-198", type_)
-node.lineno - 1,
-node.col_offset,
-"M-198",
-type_,
-)
 elif (
 numPositionalArgs == 1
 and isinstance(node.args[0], (ast.Tuple, ast.List))
 and (
 "tuple": "M-189b",
 "list": "M-190b",
 "set": "M-185",
 "dict": "M-186",
 }[node.func.id]
-self.__error(
+self.addErrorFromNode(
-node.lineno - 1,
+node,
-node.col_offset,
 errorCode,
 type(node.args[0]).__name__.lower(),
 node.func.id,
 )
 ) or (
 numPositionalArgs == 0
 and numKeywordArgs == 0
 and node.func.id in ("tuple", "list")
 ):
-self.__error(
+self.addErrorFromNode(node, "M-188", node.func.id)
-node.lineno - 1, node.col_offset, "M-188", node.func.id
-)
 elif (
 node.func.id in {"list", "reversed"}
 and numPositionalArgs > 0
 and isinstance(node.args[0], ast.Call)
 if isinstance(kw.value, ast.Constant)
 else None
 )
 if reverseFlagValue is None:
-self.__error(
+self.addErrorFromNode(
-node.lineno - 1,
+node, "M-193a", node.func.id, node.args[0].func.id
-node.col_offset,
-"M-193a",
-node.func.id,
-node.args[0].func.id,
 )
 else:
-self.__error(
+self.addErrorFromNode(
-node.lineno - 1,
+node,
-node.col_offset,
 "M-193b",
 node.func.id,
 node.args[0].func.id,
 not reverseFlagValue,
 )
 else:
-self.__error(
+self.addErrorFromNode(
-node.lineno - 1,
+node, "M-193c", node.func.id, node.args[0].func.id
-node.col_offset,
-"M-193c",
-node.func.id,
-node.args[0].func.id,
 )
 elif (
 numPositionalArgs > 0
 and isinstance(node.args[0], ast.Call)
 and node.args[0].func.id in {"list", "tuple"}
 )
 or (node.func.id == "set" and node.args[0].func.id == "set")
 )
 ):
-self.__error(
+self.addErrorFromNode(
-node.lineno - 1,
+node, "M-194", node.args[0].func.id, node.func.id
-node.col_offset,
-"M-194",
-node.args[0].func.id,
-node.func.id,
 )
 elif (
 node.func.id in {"reversed", "set", "sorted"}
 and numPositionalArgs > 0
 and isinstance(node.args[0].slice.step, ast.UnaryOp)
 and isinstance(node.args[0].slice.step.op, ast.USub)
 and isinstance(node.args[0].slice.step.operand, ast.Constant)
 and node.args[0].slice.step.operand.n == 1
 ):
-self.__error(
+self.addErrorFromNode(node, "M-195", node.func.id)
-node.lineno - 1, node.col_offset, "M-195", node.func.id
-)
 elif (
 node.func.id == "map"
 and node not in visitedMapCalls
 and len(node.args) == 2
 and isinstance(node.args[0], ast.Lambda)
 ):
-self.__error(
+self.addErrorFromNode(node, "M-197", "generator expression")
-node.lineno - 1,
-node.col_offset,
-"M-197",
-"generator expression",
-)
 elif (
 node.func.id in ("list", "set", "dict")
 and len(node.args) == 1
 and isinstance(node.args[0], ast.Call)
 ):
 rewriteable = False
 if rewriteable:
 comprehensionType = f"{node.func.id} comprehension"
-self.__error(
+self.addErrorFromNode(node, "M-197", comprehensionType)
-node.lineno - 1, node.col_offset, "M-197", comprehensionType
-)
 elif isinstance(node, (ast.DictComp, ast.ListComp, ast.SetComp)) and (
 len(node.generators) == 1
 and not node.generators[0].ifs
 and not node.generators[0].is_async
 and isinstance(node.generators[0].target.elts[0], ast.Name)
 and node.generators[0].target.elts[0].id == node.key.id
 and isinstance(node.generators[0].target.elts[1], ast.Name)
 and node.generators[0].target.elts[1].id == node.value.id
 ):
-self.__error(
+self.addErrorFromNode(node, "M-196", compType[node.__class__])
-node.lineno - 1,
-node.col_offset,
-"M-196",
-compType[node.__class__],
-)
 elif (
 isinstance(node, ast.DictComp)
 and isinstance(node.key, ast.Name)
 and isinstance(node.value, ast.Constant)
 and isinstance(node.generators[0].target, ast.Name)
 and node.key.id == node.generators[0].target.id
 ):
-self.__error(
+self.addErrorFromNode(node, "M-200", compType[node.__class__])
-node.lineno - 1,
-node.col_offset,
-"M-200",
-compType[node.__class__],
-)
 def __dictShouldBeChecked(self, node):
 """
 Private function to test, if the node should be checked.
 """
 if not all(AstUtilities.isString(key) for key in node.keys):
 return False
 if (
-"__IGNORE_WARNING__" in self.__source[node.lineno - 1]
+"__IGNORE_WARNING__" in self.source[node.lineno - 1]
-or "__IGNORE_WARNING_M251__" in self.__source[node.lineno - 1]
+or "__IGNORE_WARNING_M-251__" in self.source[node.lineno - 1]
+or "noqa: M-251" in self.source[node.lineno - 1]
 ):
 return False
 lineNumbers = [key.lineno for key in node.keys]
 return len(lineNumbers) == len(set(lineNumbers))
 def __checkDictWithSortedKeys(self):
 """
 Private method to check, if dictionary keys appear in sorted order.
 """
-for node in ast.walk(self.__tree):
+for node in ast.walk(self.tree):
 if isinstance(node, ast.Dict) and self.__dictShouldBeChecked(node):
 for key1, key2 in zip(node.keys, node.keys[1:]):
 if key2.value < key1.value:
-self.__error(
+self.addErrorFromNode(key2, "M-251", key2.value, key1.value)
-key2.lineno - 1,
-key2.col_offset,
-"M-251",
-key2.value,
-key1.value,
-)
 def __checkGettext(self):
 """
 Private method to check the 'gettext' import statement.
 """
-for node in ast.walk(self.__tree):
+for node in ast.walk(self.tree):
 if isinstance(node, ast.ImportFrom) and any(
 name.asname == "_" for name in node.names
 ):
-self.__error(
+self.addErrorFromNode(node, "M-711", node.names[0].name)
-node.lineno - 1, node.col_offset, "M-711", node.names[0].name
-)
 def __checkBugBear(self):
 """
 Private method for bugbear checks.
 """
 visitor = BugBearVisitor()
-visitor.visit(self.__tree)
+visitor.visit(self.tree)
 for violation in visitor.violations:
-node = violation[0]
+self.addErrorFromNode(*violation)
-reason = violation[1]
-params = violation[2:]
-self.__error(node.lineno - 1, node.col_offset, reason, *params)
 def __checkReturn(self):
 """
 Private method to check return statements.
 """
 visitor = ReturnVisitor()
-visitor.visit(self.__tree)
+visitor.visit(self.tree)
 for violation in visitor.violations:
-node = violation[0]
+self.addErrorFromNode(*violation)
-reason = violation[1]
-self.__error(node.lineno - 1, node.col_offset, reason)
 def __checkDateTime(self):
 """
 Private method to check use of naive datetime functions.
 """
 # step 1: generate an augmented node tree containing parent info
 #         for each child node
-tree = copy.deepcopy(self.__tree)
+tree = copy.deepcopy(self.tree)
 for node in ast.walk(tree):
 for childNode in ast.iter_child_nodes(node):
 childNode._dtCheckerParent = node
 # step 2: perform checks and report issues
 visitor = DateTimeVisitor()
 visitor.visit(tree)
 for violation in visitor.violations:
-node = violation[0]
+self.addErrorFromNode(*violation)
-reason = violation[1]
-self.__error(node.lineno - 1, node.col_offset, reason)
 def __checkSysVersion(self):
 """
 Private method to check the use of sys.version and sys.version_info.
 """
 visitor = SysVersionVisitor()
-visitor.visit(self.__tree)
+visitor.visit(self.tree)
 for violation in visitor.violations:
-node = violation[0]
+self.addErrorFromNode(*violation)
-reason = violation[1]
-self.__error(node.lineno - 1, node.col_offset, reason)
 def __checkProperties(self):
 """
 Private method to check for issue with property related methods.
 """
 properties = []
-for node in ast.walk(self.__tree):
+for node in ast.walk(self.tree):
 if isinstance(node, ast.ClassDef):
 properties.clear()
 elif isinstance(node, ast.FunctionDef):
 propertyCount = 0
 # property getter method
 if isinstance(decorator, ast.Name) and decorator.id == "property":
 propertyCount += 1
 properties.append(node.name)
 if len(node.args.args) != 1:
-self.__error(
+self.addErrorFromNode(node, "M-260", len(node.args.args))
-node.lineno - 1,
-node.col_offset,
-"M-260",
-len(node.args.args),
-)
 if isinstance(decorator, ast.Attribute):
 # property setter method
 if decorator.attr == "setter":
 propertyCount += 1
 if node.name != decorator.value.id:
 if node.name in properties:
-self.__error(
+self.addErrorFromNode(
-node.lineno - 1,
+node, "M-265", node.name, decorator.value.id
-node.col_offset,
-"M-265",
-node.name,
-decorator.value.id,
 )
 else:
-self.__error(
+self.addErrorFromNode(
-node.lineno - 1,
+node, "M-263", decorator.value.id, node.name
-node.col_offset,
-"M-263",
-decorator.value.id,
-node.name,
 )
 if len(node.args.args) != 2:
-self.__error(
+self.addErrorFromNode(
-node.lineno - 1,
+node, "M-261", len(node.args.args)
-node.col_offset,
-"M-261",
-len(node.args.args),
 )
 # property deleter method
 if decorator.attr == "deleter":
 propertyCount += 1
 if node.name != decorator.value.id:
 if node.name in properties:
-self.__error(
+self.addErrorFromNode(
-node.lineno - 1,
+node, "M-266", node.name, decorator.value.id
-node.col_offset,
-"M-266",
-node.name,
-decorator.value.id,
 )
 else:
-self.__error(
+self.addErrorFromNode(
-node.lineno - 1,
+node, "M-264", decorator.value.id, node.name
-node.col_offset,
-"M-264",
-decorator.value.id,
-node.name,
 )
 if len(node.args.args) != 1:
-self.__error(
+self.addErrorFromNode(
-node.lineno - 1,
+node, "M-262", len(node.args.args)
-node.col_offset,
-"M-262",
-len(node.args.args),
 )
 if propertyCount > 1:
-self.__error(node.lineno - 1, node.col_offset, "M-267", node.name)
+self.addErrorFromNode(node, "M-267", node.name)
 #######################################################################
 ## The following methods check for implicitly concatenated strings.
 ##
 ## These methods are adapted from: flake8-implicit-str-concat v0.5.0
 tokenize.COMMENT,
 )
 )
 for a, b in pairwise(tokensWithoutWhitespace):
 if self.__isImplicitStringConcat(a, b):
-self.__error(
+self.addError(
-a.end[0] - 1,
+a.end[0],
 a.end[1],
 "M-851" if a.end[0] == b.start[0] else "M-852",
 )
 def __checkExplicitStringConcat(self):
 """
 Private method to check for explicitly concatenated strings.
 """
-for node in ast.walk(self.__tree):
+for node in ast.walk(self.tree):
 if (
 isinstance(node, ast.BinOp)
 and isinstance(node.op, ast.Add)
 and all(
 AstUtilities.isBaseString(operand)
 or isinstance(operand, ast.JoinedStr)
 for operand in (node.left, node.right)
 )
 ):
-self.__error(node.lineno - 1, node.col_offset, "M-853")
+self.addErrorFromNode(node, "M-853")
 #################################################################################
 ## The following method checks default match cases.
 #################################################################################
 def __checkDefaultMatchCase(self):
 """
 Private method to check the default match case.
 """
 visitor = DefaultMatchCaseVisitor()
-visitor.visit(self.__tree)
+visitor.visit(self.tree)
 for violation in visitor.violations:
-node = violation[0]
+self.addErrorFromNode(*violation)
-reason = violation[1]
-self.__error(node.lineno - 1, node.col_offset, reason)
-class TextVisitor(ast.NodeVisitor):
-"""
-Class implementing a node visitor for bytes and str instances.
-It tries to detect docstrings as string of the first expression of each
-module, class or function.
-"""
-# modeled after the string format flake8 extension
-def __init__(self):
-"""
-Constructor
-"""
-super().__init__()
-self.nodes = []
-self.calls = {}
-def __addNode(self, node):
-"""
-Private method to add a node to our list of nodes.
-@param node reference to the node to add
-@type ast.AST
-"""
-if not hasattr(node, "is_docstring"):
-node.is_docstring = False
-self.nodes.append(node)
-def visit_Constant(self, node):
-"""
-Public method to handle constant nodes.
-@param node reference to the bytes node
-@type ast.Constant
-"""
-if AstUtilities.isBaseString(node):
-self.__addNode(node)
-else:
-super().generic_visit(node)
-def __visitDefinition(self, node):
-"""
-Private method handling class and function definitions.
-@param node reference to the node to handle
-@type ast.FunctionDef, ast.AsyncFunctionDef or ast.ClassDef
-"""
-# Manually traverse class or function definition
-# * Handle decorators normally
-# * Use special check for body content
-# * Don't handle the rest (e.g. bases)
-for decorator in node.decorator_list:
-self.visit(decorator)
-self.__visitBody(node)
-def __visitBody(self, node):
-"""
-Private method to traverse the body of the node manually.
-If the first node is an expression which contains a string or bytes it
-marks that as a docstring.
-@param node reference to the node to traverse
-@type ast.AST
-"""
-if (
-node.body
-and isinstance(node.body[0], ast.Expr)
-and AstUtilities.isBaseString(node.body[0].value)
-):
-node.body[0].value.is_docstring = True
-for subnode in node.body:
-self.visit(subnode)
-def visit_Module(self, node):
-"""
-Public method to handle a module.
-@param node reference to the node to handle
-@type ast.Module
-"""
-self.__visitBody(node)
-def visit_ClassDef(self, node):
-"""
-Public method to handle a class definition.
-@param node reference to the node to handle
-@type ast.ClassDef
-"""
-# Skipped nodes: ('name', 'bases', 'keywords', 'starargs', 'kwargs')
-self.__visitDefinition(node)
-def visit_FunctionDef(self, node):
-"""
-Public method to handle a function definition.
-@param node reference to the node to handle
-@type ast.FunctionDef
-"""
-# Skipped nodes: ('name', 'args', 'returns')
-self.__visitDefinition(node)
-def visit_AsyncFunctionDef(self, node):
-"""
-Public method to handle an asynchronous function definition.
-@param node reference to the node to handle
-@type ast.AsyncFunctionDef
-"""
-# Skipped nodes: ('name', 'args', 'returns')
-self.__visitDefinition(node)
-def visit_Call(self, node):
-"""
-Public method to handle a function call.
-@param node reference to the node to handle
-@type ast.Call
-"""
-if isinstance(node.func, ast.Attribute) and node.func.attr == "format":
-if AstUtilities.isBaseString(node.func.value):
-self.calls[node.func.value] = (node, False)
-elif (
-isinstance(node.func.value, ast.Name)
-and node.func.value.id == "str"
-and node.args
-and AstUtilities.isBaseString(node.args[0])
-):
-self.calls[node.args[0]] = (node, True)
-super().generic_visit(node)
-#######################################################################
-## BugBearVisitor
-##
-## adapted from: flake8-bugbear v24.12.12
-##
-## Original: Copyright (c) 2016 Łukasz Langa
-#######################################################################
-BugBearContext = namedtuple("BugBearContext", ["node", "stack"])
-@dataclass
-class M540CaughtException:
-"""
-Class to hold the data for a caught exception.
-"""
-name: str
-hasNote: bool
-class M541UnhandledKeyType:
-"""
-Class to hold a dictionary key of a type that we do not check for duplicates.
-"""
-class M541VariableKeyType:
-"""
-Class to hold the name of a variable key type.
-"""
-def __init__(self, name):
-"""
-Constructor
-@param name name of the variable key type
-@type str
-"""
-self.name = name
-class BugBearVisitor(ast.NodeVisitor):
-"""
-Class implementing a node visitor to check for various topics.
-"""
-CONTEXTFUL_NODES = (
-ast.Module,
-ast.ClassDef,
-ast.AsyncFunctionDef,
-ast.FunctionDef,
-ast.Lambda,
-ast.ListComp,
-ast.SetComp,
-ast.DictComp,
-ast.GeneratorExp,
-)
-FUNCTION_NODES = (
-ast.AsyncFunctionDef,
-ast.FunctionDef,
-ast.Lambda,
-)
-NodeWindowSize = 4
-def __init__(self):
-"""
-Constructor
-"""
-super().__init__()
-self.nodeWindow = []
-self.violations = []
-self.contexts = []
-self.__M523Seen = set()
-self.__M505Imports = set()
-self.__M540CaughtException = None
-self.__inTryStar = ""
-@property
-def nodeStack(self):
-"""
-Public method to get a reference to the most recent node stack.
-@return reference to the most recent node stack
-@rtype list
-"""
-if len(self.contexts) == 0:
-return []
-context, stack = self.contexts[-1]
-return stack
-def __isIdentifier(self, arg):
-"""
-Private method to check if arg is a valid identifier.
-See https://docs.python.org/2/reference/lexical_analysis.html#identifiers
-@param arg reference to an argument node
-@type ast.Node
-@return flag indicating a valid identifier
-@rtype TYPE
-"""
-if not AstUtilities.isString(arg):
-return False
-return (
-re.match(r"^[A-Za-z_][A-Za-z0-9_]*$", AstUtilities.getValue(arg))
-is not None
-)
-def toNameStr(self, node):
-"""
-Public method to turn Name and Attribute nodes to strings, handling any
-depth of attribute accesses.
-@param node reference to the node
-@type ast.Name or ast.Attribute
-@return string representation
-@rtype str
-"""
-if isinstance(node, ast.Name):
-return node.id
-elif isinstance(node, ast.Call):
-return self.toNameStr(node.func)
-elif isinstance(node, ast.Attribute):
-inner = self.toNameStr(node.value)
-if inner is None:
-return None
-return f"{inner}.{node.attr}"
-else:
-return None
-def __typesafeIssubclass(self, obj, classOrTuple):
-"""
-Private method implementing a type safe issubclass() function.
-@param obj reference to the object to be tested
-@type Any
-@param classOrTuple type to check against
-@type type
-@return flag indicating a subclass
-@rtype bool
-"""
-try:
-return issubclass(obj, classOrTuple)
-except TypeError:
-# User code specifies a type that is not a type in our current run.
-# Might be their error, might be a difference in our environments.
-# We don't know so we ignore this.
-return False
-def __getAssignedNames(self, loopNode):
-"""
-Private method to get the names of a for loop.
-@param loopNode reference to the node to be processed
-@type ast.For
-@yield DESCRIPTION
-@ytype TYPE
-"""
-loopTargets = (ast.For, ast.AsyncFor, ast.comprehension)
-for node in self.__childrenInScope(loopNode):
-if isinstance(node, (ast.Assign)):
-for child in node.targets:
-yield from self.__namesFromAssignments(child)
-if isinstance(node, loopTargets + (ast.AnnAssign, ast.AugAssign)):
-yield from self.__namesFromAssignments(node.target)
-def __namesFromAssignments(self, assignTarget):
-"""
-Private method to get names of an assignment.
-@param assignTarget reference to the node to be processed
-@type ast.Node
-@yield name of the assignment
-@ytype str
-"""
-if isinstance(assignTarget, ast.Name):
-yield assignTarget.id
-elif isinstance(assignTarget, ast.Starred):
-yield from self.__namesFromAssignments(assignTarget.value)
-elif isinstance(assignTarget, (ast.List, ast.Tuple)):
-for child in assignTarget.elts:
-yield from self.__namesFromAssignments(child)
-def __childrenInScope(self, node):
-"""
-Private method to get all child nodes in the given scope.
-@param node reference to the node to be processed
-@type ast.Node
-@yield reference to a child node
-@ytype ast.Node
-"""
-yield node
-if not isinstance(node, BugBearVisitor.FUNCTION_NODES):
-for child in ast.iter_child_nodes(node):
-yield from self.__childrenInScope(child)
-def __flattenExcepthandler(self, node):
-"""
-Private method to flatten the list of exceptions handled by an except handler.
-@param node reference to the node to be processed
-@type ast.Node
-@yield reference to the exception type node
-@ytype ast.Node
-"""
-if not isinstance(node, ast.Tuple):
-yield node
-return
-exprList = node.elts.copy()
-while len(exprList):
-expr = exprList.pop(0)
-if isinstance(expr, ast.Starred) and isinstance(
-expr.value, (ast.List, ast.Tuple)
-):
-exprList.extend(expr.value.elts)
-continue
-yield expr
-def __checkRedundantExcepthandlers(self, names, node, inTryStar):
-"""
-Private method to check for redundant exception types in an exception handler.
-@param names list of exception types to be checked
-@type list of ast.Name
-@param node reference to the exception handler node
-@type ast.ExceptionHandler
-@param inTryStar character indicating an 'except*' handler
-@type str
-@return tuple containing the error data
-@rtype tuple of (ast.Node, str, str, str, str)
-"""
-redundantExceptions = {
-"OSError": {
-# All of these are actually aliases of OSError since Python 3.3
-"IOError",
-"EnvironmentError",
-"WindowsError",
-"mmap.error",
-"socket.error",
-"select.error",
-},
-"ValueError": {
-"binascii.Error",
-},
-}
-# See if any of the given exception names could be removed, e.g. from:
-#    (MyError, MyError)  # duplicate names
-#    (MyError, BaseException)  # everything derives from the Base
-#    (Exception, TypeError)  # builtins where one subclasses another
-#    (IOError, OSError)  # IOError is an alias of OSError since Python3.3
-# but note that other cases are impractical to handle from the AST.
-# We expect this is mostly useful for users who do not have the
-# builtin exception hierarchy memorised, and include a 'shadowed'
-# subtype without realising that it's redundant.
-good = sorted(set(names), key=names.index)
-if "BaseException" in good:
-good = ["BaseException"]
-# Remove redundant exceptions that the automatic system either handles
-# poorly (usually aliases) or can't be checked (e.g. it's not an
-# built-in exception).
-for primary, equivalents in redundantExceptions.items():
-if primary in good:
-good = [g for g in good if g not in equivalents]
-for name, other in itertools.permutations(tuple(good), 2):
-if (
-self.__typesafeIssubclass(
-getattr(builtins, name, type), getattr(builtins, other, ())
-)
-and name in good
-):
-good.remove(name)
-if good != names:
-desc = good[0] if len(good) == 1 else "({0})".format(", ".join(good))
-as_ = " as " + node.name if node.name is not None else ""
-return (node, "M-514", ", ".join(names), as_, desc, inTryStar)
-return None
-def __walkList(self, nodes):
-"""
-Private method to walk a given list of nodes.
-@param nodes list of nodes to walk
-@type list of ast.Node
-@yield node references as determined by the ast.walk() function
-@ytype ast.Node
-"""
-for node in nodes:
-yield from ast.walk(node)
-def __getNamesFromTuple(self, node):
-"""
-Private method to get the names from an ast.Tuple node.
-@param node ast node to be processed
-@type ast.Tuple
-@yield names
-@ytype str
-"""
-for dim in node.elts:
-if isinstance(dim, ast.Name):
-yield dim.id
-elif isinstance(dim, ast.Tuple):
-yield from self.__getNamesFromTuple(dim)
-def __getDictCompLoopAndNamedExprVarNames(self, node):
-"""
-Private method to get the names of comprehension loop variables.
-@param node ast node to be processed
-@type ast.DictComp
-@yield loop variable names
-@ytype str
-"""
-finder = NamedExprFinder()
-for gen in node.generators:
-if isinstance(gen.target, ast.Name):
-yield gen.target.id
-elif isinstance(gen.target, ast.Tuple):
-yield from self.__getNamesFromTuple(gen.target)
-finder.visit(gen.ifs)
-yield from finder.getNames().keys()
-def __inClassInit(self):
-"""
-Private method to check, if we are inside an '__init__' method.
-@return flag indicating being within the '__init__' method
-@rtype bool
-"""
-return (
-len(self.contexts) >= 2
-and isinstance(self.contexts[-2].node, ast.ClassDef)
-and isinstance(self.contexts[-1].node, ast.FunctionDef)
-and self.contexts[-1].node.name == "__init__"
-)
-def visit_Return(self, node):
-"""
-Public method to handle 'Return' nodes.
-@param node reference to the node to be processed
-@type ast.Return
-"""
-if self.__inClassInit() and node.value is not None:
-self.violations.append((node, "M-537"))
-self.generic_visit(node)
-def visit_Yield(self, node):
-"""
-Public method to handle 'Yield' nodes.
-@param node reference to the node to be processed
-@type ast.Yield
-"""
-if self.__inClassInit():
-self.violations.append((node, "M-537"))
-self.generic_visit(node)
-def visit_YieldFrom(self, node) -> None:
-"""
-Public method to handle 'YieldFrom' nodes.
-@param node reference to the node to be processed
-@type ast.YieldFrom
-"""
-if self.__inClassInit():
-self.violations.append((node, "M-537"))
-self.generic_visit(node)
-def visit(self, node):
-"""
-Public method to traverse a given AST node.
-@param node AST node to be traversed
-@type ast.Node
-"""
-isContextful = isinstance(node, BugBearVisitor.CONTEXTFUL_NODES)
-if isContextful:
-context = BugBearContext(node, [])
-self.contexts.append(context)
-self.nodeStack.append(node)
-self.nodeWindow.append(node)
-self.nodeWindow = self.nodeWindow[-BugBearVisitor.NodeWindowSize :]
-super().visit(node)
-self.nodeStack.pop()
-if isContextful:
-self.contexts.pop()
-self.__checkForM518(node)
-def visit_ExceptHandler(self, node):
-"""
-Public method to handle exception handlers.
-@param node reference to the node to be processed
-@type ast.ExceptHandler
-"""
-if node.type is None:
-# bare except is handled by pycodestyle already
-self.generic_visit(node)
-return
-oldM540CaughtException = self.__M540CaughtException
-if node.name is None:
-self.__M540CaughtException = None
-else:
-self.__M540CaughtException = M540CaughtException(node.name, False)
-names = self.__checkForM513_M514_M529_M530(node)
-if "BaseException" in names and not ExceptBaseExceptionVisitor(node).reRaised():
-self.violations.append((node, "M-536"))
-self.generic_visit(node)
-if (
-self.__M540CaughtException is not None
-and self.__M540CaughtException.hasNote
-):
-self.violations.append((node, "M-540"))
-self.__M540CaughtException = oldM540CaughtException
-def visit_UAdd(self, node):
-"""
-Public method to handle unary additions.
-@param node reference to the node to be processed
-@type ast.UAdd
-"""
-trailingNodes = list(map(type, self.nodeWindow[-4:]))
-if trailingNodes == [ast.UnaryOp, ast.UAdd, ast.UnaryOp, ast.UAdd]:
-originator = self.nodeWindow[-4]
-self.violations.append((originator, "M-502"))
-self.generic_visit(node)
-def visit_Call(self, node):
-"""
-Public method to handle a function call.
-@param node reference to the node to be processed
-@type ast.Call
-"""
-isM540AddNote = False
-if isinstance(node.func, ast.Attribute):
-self.__checkForM505(node)
-isM540AddNote = self.__checkForM540AddNote(node.func)
-else:
-with contextlib.suppress(AttributeError, IndexError):
-# bad super() call
-if isinstance(node.func, ast.Name) and node.func.id == "super":
-args = node.args
-if (
-len(args) == 2
-and isinstance(args[0], ast.Attribute)
-and isinstance(args[0].value, ast.Name)
-and args[0].value.id == "self"
-and args[0].attr == "__class__"
-):
-self.violations.append((node, "M-582"))
-# bad getattr and setattr
-if (
-node.func.id in ("getattr", "hasattr")
-and node.args[1].value == "__call__"
-):
-self.violations.append((node, "M-504"))
-if (
-node.func.id == "getattr"
-and len(node.args) == 2
-and self.__isIdentifier(node.args[1])
-and iskeyword(AstUtilities.getValue(node.args[1]))
-):
-self.violations.append((node, "M-509"))
-elif (
-node.func.id == "setattr"
-and len(node.args) == 3
-and self.__isIdentifier(node.args[1])
-and iskeyword(AstUtilities.getValue(node.args[1]))
-):
-self.violations.append((node, "M-510"))
-self.__checkForM526(node)
-self.__checkForM528(node)
-self.__checkForM534(node)
-self.__checkForM539(node)
-# no need for copying, if used in nested calls it will be set to None
-currentM540CaughtException = self.__M540CaughtException
-if not isM540AddNote:
-self.__checkForM540Usage(node.args)
-self.__checkForM540Usage(node.keywords)
-self.generic_visit(node)
-if isM540AddNote:
-# Avoid nested calls within the parameter list using the variable itself.
-# e.g. `e.add_note(str(e))`
-self.__M540CaughtException = currentM540CaughtException
-def visit_Module(self, node):
-"""
-Public method to handle a module node.
-@param node reference to the node to be processed
-@type ast.Module
-"""
-self.generic_visit(node)
-def visit_Assign(self, node):
-"""
-Public method to handle assignments.
-@param node reference to the node to be processed
-@type ast.Assign
-"""
-self.__checkForM540Usage(node.value)
-if len(node.targets) == 1:
-target = node.targets[0]
-if (
-isinstance(target, ast.Attribute)
-and isinstance(target.value, ast.Name)
-and (target.value.id, target.attr) == ("os", "environ")
-):
-self.violations.append((node, "M-503"))
-self.generic_visit(node)
-def visit_For(self, node):
-"""
-Public method to handle 'for' statements.
-@param node reference to the node to be processed
-@type ast.For
-"""
-self.__checkForM507(node)
-self.__checkForM520(node)
-self.__checkForM523(node)
-self.__checkForM531(node)
-self.__checkForM569(node)
-self.generic_visit(node)
-def visit_AsyncFor(self, node):
-"""
-Public method to handle 'for' statements.
-@param node reference to the node to be processed
-@type ast.AsyncFor
-"""
-self.__checkForM507(node)
-self.__checkForM520(node)
-self.__checkForM523(node)
-self.__checkForM531(node)
-self.generic_visit(node)
-def visit_While(self, node):
-"""
-Public method to handle 'while' statements.
-@param node reference to the node to be processed
-@type ast.While
-"""
-self.__checkForM523(node)
-self.generic_visit(node)
-def visit_ListComp(self, node):
-"""
-Public method to handle list comprehensions.
-@param node reference to the node to be processed
-@type ast.ListComp
-"""
-self.__checkForM523(node)
-self.generic_visit(node)
-def visit_SetComp(self, node):
-"""
-Public method to handle set comprehensions.
-@param node reference to the node to be processed
-@type ast.SetComp
-"""
-self.__checkForM523(node)
-self.generic_visit(node)
-def visit_DictComp(self, node):
-"""
-Public method to handle dictionary comprehensions.
-@param node reference to the node to be processed
-@type ast.DictComp
-"""
-self.__checkForM523(node)
-self.__checkForM535(node)
-self.generic_visit(node)
-def visit_GeneratorExp(self, node):
-"""
-Public method to handle generator expressions.
-@param node reference to the node to be processed
-@type ast.GeneratorExp
-"""
-self.__checkForM523(node)
-self.generic_visit(node)
-def visit_Assert(self, node):
-"""
-Public method to handle 'assert' statements.
-@param node reference to the node to be processed
-@type ast.Assert
-"""
-if (
-AstUtilities.isNameConstant(node.test)
-and AstUtilities.getValue(node.test) is False
-):
-self.violations.append((node, "M-511"))
-self.generic_visit(node)
-def visit_AsyncFunctionDef(self, node):
-"""
-Public method to handle async function definitions.
-@param node reference to the node to be processed
-@type ast.AsyncFunctionDef
-"""
-self.__checkForM506_M508(node)
-self.generic_visit(node)
-def visit_FunctionDef(self, node):
-"""
-Public method to handle function definitions.
-@param node reference to the node to be processed
-@type ast.FunctionDef
-"""
-self.__checkForM506_M508(node)
-self.__checkForM519(node)
-self.__checkForM521(node)
-self.generic_visit(node)
-def visit_ClassDef(self, node):
-"""
-Public method to handle class definitions.
-@param node reference to the node to be processed
-@type ast.ClassDef
-"""
-self.__checkForM521(node)
-self.__checkForM524_M527(node)
-self.generic_visit(node)
-def visit_Try(self, node):
-"""
-Public method to handle 'try' statements.
-@param node reference to the node to be processed
-@type ast.Try
-"""
-self.__checkForM512(node)
-self.__checkForM525(node)
-self.generic_visit(node)
-def visit_TryStar(self, node):
-"""
-Public method to handle 'except*' statements.
-@param node reference to the node to be processed
-@type ast.TryStar
-"""
-outerTryStar = self.__inTryStar
-self.__inTryStar = "*"
-self.visit_Try(node)
-self.__inTryStar = outerTryStar
-def visit_Compare(self, node):
-"""
-Public method to handle comparison statements.
-@param node reference to the node to be processed
-@type ast.Compare
-"""
-self.__checkForM515(node)
-self.generic_visit(node)
-def visit_Raise(self, node):
-"""
-Public method to handle 'raise' statements.
-@param node reference to the node to be processed
-@type ast.Raise
-"""
-if node.exc is None:
-self.__M540CaughtException = None
-else:
-self.__checkForM540Usage(node.exc)
-self.__checkForM540Usage(node.cause)
-self.__checkForM516(node)
-self.generic_visit(node)
-def visit_With(self, node):
-"""
-Public method to handle 'with' statements.
-@param node reference to the node to be processed
-@type ast.With
-"""
-self.__checkForM517(node)
-self.__checkForM522(node)
-self.generic_visit(node)
-def visit_JoinedStr(self, node):
-"""
-Public method to handle f-string arguments.
-@param node reference to the node to be processed
-@type ast.JoinedStr
-"""
-for value in node.values:
-if isinstance(value, ast.FormattedValue):
-return
-self.violations.append((node, "M-581"))
-def visit_AnnAssign(self, node):
-"""
-Public method to check annotated assign statements.
-@param node reference to the node to be processed
-@type ast.AnnAssign
-"""
-self.__checkForM532(node)
-self.__checkForM540Usage(node.value)
-self.generic_visit(node)
-def visit_Import(self, node):
-"""
-Public method to check imports.
-@param node reference to the node to be processed
-@type ast.Import
-"""
-self.__checkForM505(node)
-self.generic_visit(node)
-def visit_ImportFrom(self, node):
-"""
-Public method to check from imports.
-@param node reference to the node to be processed
-@type ast.Import
-"""
-self.visit_Import(node)
-def visit_Set(self, node):
-"""
-Public method to check a set.
-@param node reference to the node to be processed
-@type ast.Set
-"""
-self.__checkForM533(node)
-self.generic_visit(node)
-def visit_Dict(self, node):
-"""
-Public method to check a dictionary.
-@param node reference to the node to be processed
-@type ast.Dict
-"""
-self.__checkForM541(node)
-self.generic_visit(node)
-def __checkForM505(self, node):
-"""
-Private method to check the use of *strip().
-@param node reference to the node to be processed
-@type ast.Call
-"""
-if isinstance(node, ast.Import):
-for name in node.names:
-self.__M505Imports.add(name.asname or name.name)
-elif isinstance(node, ast.ImportFrom):
-for name in node.names:
-self.__M505Imports.add(f"{node.module}.{name.name or name.asname}")
-elif isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute):
-if node.func.attr not in ("lstrip", "rstrip", "strip"):
-return  # method name doesn't match
-if (
-isinstance(node.func.value, ast.Name)
-and node.func.value.id in self.__M505Imports
-):
-return  # method is being run on an imported module
-if len(node.args) != 1 or not AstUtilities.isString(node.args[0]):
-return  # used arguments don't match the builtin strip
-value = AstUtilities.getValue(node.args[0])
-if len(value) == 1:
-return  # stripping just one character
-if len(value) == len(set(value)):
-return  # no characters appear more than once
-self.violations.append((node, "M-505"))
-def __checkForM506_M508(self, node):
-"""
-Private method to check the use of mutable literals, comprehensions and calls.
-@param node reference to the node to be processed
-@type ast.AsyncFunctionDef or ast.FunctionDef
-"""
-visitor = FunctionDefDefaultsVisitor("M-506", "M-508")
-visitor.visit(node.args.defaults + node.args.kw_defaults)
-self.violations.extend(visitor.errors)
-def __checkForM507(self, node):
-"""
-Private method to check for unused loop variables.
-@param node reference to the node to be processed
-@type ast.For or ast.AsyncFor
-"""
-targets = NameFinder()
-targets.visit(node.target)
-ctrlNames = set(filter(lambda s: not s.startswith("_"), targets.getNames()))
-body = NameFinder()
-for expr in node.body:
-body.visit(expr)
-usedNames = set(body.getNames())
-for name in sorted(ctrlNames - usedNames):
-n = targets.getNames()[name][0]
-self.violations.append((n, "M-507", name))
-def __checkForM512(self, node):
-"""
-Private method to check for return/continue/break inside finally blocks.
-@param node reference to the node to be processed
-@type ast.Try
-"""
-def _loop(node, badNodeTypes):
-if isinstance(node, (ast.AsyncFunctionDef, ast.FunctionDef)):
-return
-if isinstance(node, (ast.While, ast.For)):
-badNodeTypes = (ast.Return,)
-elif isinstance(node, badNodeTypes):
-self.violations.append((node, "M-512", self.__inTryStar))
-for child in ast.iter_child_nodes(node):
-_loop(child, badNodeTypes)
-for child in node.finalbody:
-_loop(child, (ast.Return, ast.Continue, ast.Break))
-def __checkForM513_M514_M529_M530(self, node):
-"""
-Private method to check various exception handler situations.
-@param node reference to the node to be processed
-@type ast.ExceptHandler
-@return list of exception handler names
-@rtype list of str
-"""
-handlers = self.__flattenExcepthandler(node.type)
-names = []
-badHandlers = []
-ignoredHandlers = []
-for handler in handlers:
-if isinstance(handler, (ast.Name, ast.Attribute)):
-name = self.toNameStr(handler)
-if name is None:
-ignoredHandlers.append(handler)
-else:
-names.append(name)
-elif isinstance(handler, (ast.Call, ast.Starred)):
-ignoredHandlers.append(handler)
-else:
-badHandlers.append(handler)
-if badHandlers:
-self.violations.append((node, "M-530"))
-if len(names) == 0 and not badHandlers and not ignoredHandlers:
-self.violations.append((node, "M-529", self.__inTryStar))
-elif (
-len(names) == 1
-and not badHandlers
-and not ignoredHandlers
-and isinstance(node.type, ast.Tuple)
-):
-self.violations.append((node, "M-513", *names, self.__inTryStar))
-else:
-maybeError = self.__checkRedundantExcepthandlers(
-names, node, self.__inTryStar
-)
-if maybeError is not None:
-self.violations.append(maybeError)
-return names
-def __checkForM515(self, node):
-"""
-Private method to check for pointless comparisons.
-@param node reference to the node to be processed
-@type ast.Compare
-"""
-if isinstance(self.nodeStack[-2], ast.Expr):
-self.violations.append((node, "M-515"))
-def __checkForM516(self, node):
-"""
-Private method to check for raising a literal instead of an exception.
-@param node reference to the node to be processed
-@type ast.Raise
-"""
-if (
-AstUtilities.isNameConstant(node.exc)
-or AstUtilities.isNumber(node.exc)
-or AstUtilities.isString(node.exc)
-):
-self.violations.append((node, "M-516"))
-def __checkForM517(self, node):
-"""
-Private method to check for use of the evil syntax
-'with assertRaises(Exception): or 'with pytest.raises(Exception):'.
-@param node reference to the node to be processed
-@type ast.With
-"""
-item = node.items[0]
-itemContext = item.context_expr
-if (
-hasattr(itemContext, "func")
-and (
-(
-isinstance(itemContext.func, ast.Attribute)
-and (
-itemContext.func.attr == "assertRaises"
-or (
-itemContext.func.attr == "raises"
-and isinstance(itemContext.func.value, ast.Name)
-and itemContext.func.value.id == "pytest"
-and "match" not in (kwd.arg for kwd in itemContext.keywords)
-)
-)
-)
-or (
-isinstance(itemContext.func, ast.Name)
-and itemContext.func.id == "raises"
-and isinstance(itemContext.func.ctx, ast.Load)
-and "pytest.raises" in self.__M505Imports
-and "match" not in (kwd.arg for kwd in itemContext.keywords)
-)
-)
-and len(itemContext.args) == 1
-and isinstance(itemContext.args[0], ast.Name)
-and itemContext.args[0].id in ("Exception", "BaseException")
-and not item.optional_vars
-):
-self.violations.append((node, "M-517"))
-def __checkForM518(self, node):
-"""
-Private method to check for useless expressions.
-@param node reference to the node to be processed
-@type ast.FunctionDef
-"""
-if not isinstance(node, ast.Expr):
-return
-if isinstance(
-node.value,
-(ast.List, ast.Set, ast.Dict, ast.Tuple),
-) or (
-isinstance(node.value, ast.Constant)
-and (
-isinstance(
-node.value.value,
-(int, float, complex, bytes, bool),
-)
-or node.value.value is None
-)
-):
-self.violations.append((node, "M-518", node.value.__class__.__name__))
-def __checkForM519(self, node):
-"""
-Private method to check for use of 'functools.lru_cache' or 'functools.cache'.
-@param node reference to the node to be processed
-@type ast.FunctionDef
-"""
-caches = {
-"functools.cache",
-"functools.lru_cache",
-"cache",
-"lru_cache",
-}
-if (
-len(node.decorator_list) == 0
-or len(self.contexts) < 2
-or not isinstance(self.contexts[-2].node, ast.ClassDef)
-):
-return
-# Preserve decorator order so we can get the lineno from the decorator node
-# rather than the function node (this location definition changes in Python 3.8)
-resolvedDecorators = (
-".".join(composeCallPath(decorator)) for decorator in node.decorator_list
-)
-for idx, decorator in enumerate(resolvedDecorators):
-if decorator in {"classmethod", "staticmethod"}:
-return
-if decorator in caches:
-self.violations.append((node.decorator_list[idx], "M-519"))
-return
-def __checkForM520(self, node):
-"""
-Private method to check for a loop that modifies its iterable.
-@param node reference to the node to be processed
-@type ast.For or ast.AsyncFor
-"""
-targets = NameFinder()
-targets.visit(node.target)
-ctrlNames = set(targets.getNames())
-iterset = M520NameFinder()
-iterset.visit(node.iter)
-itersetNames = set(iterset.getNames())
-for name in sorted(ctrlNames):
-if name in itersetNames:
-n = targets.getNames()[name][0]
-self.violations.append((n, "M-520"))
-def __checkForM521(self, node):
-"""
-Private method to check for use of an f-string as docstring.
-@param node reference to the node to be processed
-@type ast.FunctionDef or ast.ClassDef
-"""
-if (
-node.body
-and isinstance(node.body[0], ast.Expr)
-and isinstance(node.body[0].value, ast.JoinedStr)
-):
-self.violations.append((node.body[0].value, "M-521"))
-def __checkForM522(self, node):
-"""
-Private method to check for use of an f-string as docstring.
-@param node reference to the node to be processed
-@type ast.With
-"""
-item = node.items[0]
-itemContext = item.context_expr
-if (
-hasattr(itemContext, "func")
-and hasattr(itemContext.func, "value")
-and hasattr(itemContext.func.value, "id")
-and itemContext.func.value.id == "contextlib"
-and hasattr(itemContext.func, "attr")
-and itemContext.func.attr == "suppress"
-and len(itemContext.args) == 0
-):
-self.violations.append((node, "M-522"))
-def __checkForM523(self, loopNode):
-"""
-Private method to check that functions (including lambdas) do not use loop
-variables.
-@param loopNode reference to the node to be processed
-@type ast.For, ast.AsyncFor, ast.While, ast.ListComp, ast.SetComp,ast.DictComp,
-or ast.GeneratorExp
-"""
-safe_functions = []
-suspiciousVariables = []
-for node in ast.walk(loopNode):
-# check if function is immediately consumed to avoid false alarm
-if isinstance(node, ast.Call):
-# check for filter&reduce
-if (
-isinstance(node.func, ast.Name)
-and node.func.id in ("filter", "reduce", "map")
-) or (
-isinstance(node.func, ast.Attribute)
-and node.func.attr == "reduce"
-and isinstance(node.func.value, ast.Name)
-and node.func.value.id == "functools"
-):
-for arg in node.args:
-if isinstance(arg, BugBearVisitor.FUNCTION_NODES):
-safe_functions.append(arg)
-# check for key=
-for keyword in node.keywords:
-if keyword.arg == "key" and isinstance(
-keyword.value, BugBearVisitor.FUNCTION_NODES
-):
-safe_functions.append(keyword.value)
-# mark `return lambda: x` as safe
-# does not (currently) check inner lambdas in a returned expression
-# e.g. `return (lambda: x, )
-if isinstance(node, ast.Return) and isinstance(
-node.value, BugBearVisitor.FUNCTION_NODES
-):
-safe_functions.append(node.value)
-# find unsafe functions
-if (
-isinstance(node, BugBearVisitor.FUNCTION_NODES)
-and node not in safe_functions
-):
-argnames = {
-arg.arg for arg in ast.walk(node.args) if isinstance(arg, ast.arg)
-}
-if isinstance(node, ast.Lambda):
-bodyNodes = ast.walk(node.body)
-else:
-bodyNodes = itertools.chain.from_iterable(map(ast.walk, node.body))
-errors = []
-for name in bodyNodes:
-if isinstance(name, ast.Name) and name.id not in argnames:
-if isinstance(name.ctx, ast.Load):
-errors.append((name.lineno, name.col_offset, name.id, name))
-elif isinstance(name.ctx, ast.Store):
-argnames.add(name.id)
-for err in errors:
-if err[2] not in argnames and err not in self.__M523Seen:
-self.__M523Seen.add(err)  # dedupe across nested loops
-suspiciousVariables.append(err)
-if suspiciousVariables:
-reassignedInLoop = set(self.__getAssignedNames(loopNode))
-for err in sorted(suspiciousVariables):
-if reassignedInLoop.issuperset(err[2]):
-self.violations.append((err[3], "M-523", err[2]))
-def __checkForM524_M527(self, node):
-"""
-Private method to check for inheritance from abstract classes in abc and lack of
-any methods decorated with abstract*.
-@param node reference to the node to be processed
-@type ast.ClassDef
-"""  # __IGNORE_WARNING_D-234r__
-def isAbcClass(value, name="ABC"):
-if isinstance(value, ast.keyword):
-return value.arg == "metaclass" and isAbcClass(value.value, "ABCMeta")
-# class foo(ABC)
-# class foo(abc.ABC)
-return (isinstance(value, ast.Name) and value.id == name) or (
-isinstance(value, ast.Attribute)
-and value.attr == name
-and isinstance(value.value, ast.Name)
-and value.value.id == "abc"
-)
-def isAbstractDecorator(expr):
-return (isinstance(expr, ast.Name) and expr.id[:8] == "abstract") or (
-isinstance(expr, ast.Attribute) and expr.attr[:8] == "abstract"
-)
-def isOverload(expr):
-return (isinstance(expr, ast.Name) and expr.id == "overload") or (
-isinstance(expr, ast.Attribute) and expr.attr == "overload"
-)
-def emptyBody(body):
-def isStrOrEllipsis(node):
-return isinstance(node, ast.Constant) and (
-node.value is Ellipsis or isinstance(node.value, str)
-)
-# Function body consist solely of `pass`, `...`, and/or (doc)string literals
-return all(
-isinstance(stmt, ast.Pass)
-or (isinstance(stmt, ast.Expr) and isStrOrEllipsis(stmt.value))
-for stmt in body
-)
-# don't check multiple inheritance
-if len(node.bases) + len(node.keywords) > 1:
-return
-# only check abstract classes
-if not any(map(isAbcClass, (*node.bases, *node.keywords))):
-return
-hasMethod = False
-hasAbstractMethod = False
-if not any(map(isAbcClass, (*node.bases, *node.keywords))):
-return
-for stmt in node.body:
-# Ignore abc's that declares a class attribute that must be set
-if isinstance(stmt, ast.AnnAssign) and stmt.value is None:
-hasAbstractMethod = True
-continue
-# only check function defs
-if not isinstance(stmt, (ast.FunctionDef, ast.AsyncFunctionDef)):
-continue
-hasMethod = True
-hasAbstractDecorator = any(map(isAbstractDecorator, stmt.decorator_list))
-hasAbstractMethod |= hasAbstractDecorator
-if (
-not hasAbstractDecorator
-and emptyBody(stmt.body)
-and not any(map(isOverload, stmt.decorator_list))
-):
-self.violations.append((stmt, "M-527", stmt.name))
-if hasMethod and not hasAbstractMethod:
-self.violations.append((node, "M-524", node.name))
-def __checkForM525(self, node):
-"""
-Private method to check for exceptions being handled multiple times.
-@param node reference to the node to be processed
-@type ast.Try
-"""
-seen = []
-for handler in node.handlers:
-if isinstance(handler.type, (ast.Name, ast.Attribute)):
-name = ".".join(composeCallPath(handler.type))
-seen.append(name)
-elif isinstance(handler.type, ast.Tuple):
-# to avoid checking the same as M514, remove duplicates per except
-uniques = set()
-for entry in handler.type.elts:
-name = ".".join(composeCallPath(entry))
-uniques.add(name)
-seen.extend(uniques)
-# sort to have a deterministic output
-duplicates = sorted({x for x in seen if seen.count(x) > 1})
-for duplicate in duplicates:
-self.violations.append((node, "M-525", duplicate, self.__inTryStar))
-def __checkForM526(self, node):
-"""
-Private method to check for Star-arg unpacking after keyword argument.
-@param node reference to the node to be processed
-@type ast.Call
-"""
-if not node.keywords:
-return
-starreds = [arg for arg in node.args if isinstance(arg, ast.Starred)]
-if not starreds:
-return
-firstKeyword = node.keywords[0].value
-for starred in starreds:
-if (starred.lineno, starred.col_offset) > (
-firstKeyword.lineno,
-firstKeyword.col_offset,
-):
-self.violations.append((node, "M-526"))
-def __checkForM528(self, node):
-"""
-Private method to check for warn without stacklevel.
-@param node reference to the node to be processed
-@type ast.Call
-"""
-if (
-isinstance(node.func, ast.Attribute)
-and node.func.attr == "warn"
-and isinstance(node.func.value, ast.Name)
-and node.func.value.id == "warnings"
-and not any(kw.arg == "stacklevel" for kw in node.keywords)
-and len(node.args) < 3
-and not any(isinstance(a, ast.Starred) for a in node.args)
-and not any(kw.arg is None for kw in node.keywords)
-):
-self.violations.append((node, "M-528"))
-def __checkForM531(self, loopNode):
-"""
-Private method to check that 'itertools.groupby' isn't iterated over more than
-once.
-A warning is emitted when the generator returned by 'groupby()' is used
-more than once inside a loop body or when it's used in a nested loop.
-@param loopNode reference to the node to be processed
-@type ast.For or ast.AsyncFor
-"""
-# for <loop_node.target> in <loop_node.iter>: ...
-if isinstance(loopNode.iter, ast.Call):
-node = loopNode.iter
-if (isinstance(node.func, ast.Name) and node.func.id in ("groupby",)) or (
-isinstance(node.func, ast.Attribute)
-and node.func.attr == "groupby"
-and isinstance(node.func.value, ast.Name)
-and node.func.value.id == "itertools"
-):
-# We have an invocation of groupby which is a simple unpacking
-if isinstance(loopNode.target, ast.Tuple) and isinstance(
-loopNode.target.elts[1], ast.Name
-):
-groupName = loopNode.target.elts[1].id
-else:
-# Ignore any 'groupby()' invocation that isn't unpacked
-return
-numUsages = 0
-for node in self.__walkList(loopNode.body):
-# Handled nested loops
-if isinstance(node, ast.For):
-for nestedNode in self.__walkList(node.body):
-if (
-isinstance(nestedNode, ast.Name)
-and nestedNode.id == groupName
-):
-self.violations.append((nestedNode, "M-531"))
-# Handle multiple uses
-if isinstance(node, ast.Name) and node.id == groupName:
-numUsages += 1
-if numUsages > 1:
-self.violations.append((nestedNode, "M-531"))
-def __checkForM532(self, node):
-"""
-Private method to check for possible unintentional typing annotation.
-@param node reference to the node to be processed
-@type ast.AnnAssign
-"""
-if (
-node.value is None
-and hasattr(node.target, "value")
-and isinstance(node.target.value, ast.Name)
-and (
-isinstance(node.target, ast.Subscript)
-or (
-isinstance(node.target, ast.Attribute)
-and node.target.value.id != "self"
-)
-)
-):
-self.violations.append((node, "M-532"))
-def __checkForM533(self, node):
-"""
-Private method to check a set for duplicate items.
-@param node reference to the node to be processed
-@type ast.Set
-"""
-seen = set()
-for elt in node.elts:
-if not isinstance(elt, ast.Constant):
-continue
-if elt.value in seen:
-self.violations.append((node, "M-533", repr(elt.value)))
-else:
-seen.add(elt.value)
-def __checkForM534(self, node):
-"""
-Private method to check that re.sub/subn/split arguments flags/count/maxsplit
-are passed as keyword arguments.
-@param node reference to the node to be processed
-@type ast.Call
-"""
-if not isinstance(node.func, ast.Attribute):
-return
-func = node.func
-if not isinstance(func.value, ast.Name) or func.value.id != "re":
-return
-def check(numArgs, paramName):
-if len(node.args) > numArgs:
-arg = node.args[numArgs]
-self.violations.append((arg, "M-534", func.attr, paramName))
-if func.attr in ("sub", "subn"):
-check(3, "count")
-elif func.attr == "split":
-check(2, "maxsplit")
-def __checkForM535(self, node):
-"""
-Private method to check that a static key isn't used in a dict comprehension.
-Record a warning if a likely unchanging key is used - either a constant,
-or a variable that isn't coming from the generator expression.
-@param node reference to the node to be processed
-@type ast.DictComp
-"""
-if isinstance(node.key, ast.Constant):
-self.violations.append((node, "M-535", node.key.value))
-elif isinstance(
-node.key, ast.Name
-) and node.key.id not in self.__getDictCompLoopAndNamedExprVarNames(node):
-self.violations.append((node, "M-535", node.key.id))
-def __checkForM539(self, node):
-"""
-Private method to check for correct ContextVar usage.
-@param node reference to the node to be processed
-@type ast.Call
-"""
-if not (
-(isinstance(node.func, ast.Name) and node.func.id == "ContextVar")
-or (
-isinstance(node.func, ast.Attribute)
-and node.func.attr == "ContextVar"
-and isinstance(node.func.value, ast.Name)
-and node.func.value.id == "contextvars"
-)
-):
-return
-# ContextVar only takes one kw currently, but better safe than sorry
-for kw in node.keywords:
-if kw.arg == "default":
-break
-else:
-return
-visitor = FunctionDefDefaultsVisitor("M-539", "M-539")
-visitor.visit(kw.value)
-self.violations.extend(visitor.errors)
-def __checkForM540AddNote(self, node):
-"""
-Private method to check add_note usage.
-@param node reference to the node to be processed
-@type ast.Attribute
-@return flag
-@rtype bool
-"""
-if (
-node.attr == "add_note"
-and isinstance(node.value, ast.Name)
-and self.__M540CaughtException
-and node.value.id == self.__M540CaughtException.name
-):
-self.__M540CaughtException.hasNote = True
-return True
-return False
-def __checkForM540Usage(self, node):
-"""
-Private method to check the usage of exceptions with added note.
-@param node reference to the node to be processed
-@type ast.expr or None
-"""  # noqa: D-234y
-def superwalk(node: ast.AST | list[ast.AST]):
-"""
-Function to walk an AST node or a list of AST nodes.
-@param node reference to the node or a list of nodes to be processed
-@type ast.AST or list[ast.AST]
-@yield next node to be processed
-@ytype ast.AST
-"""
-if isinstance(node, list):
-for n in node:
-yield from ast.walk(n)
-else:
-yield from ast.walk(node)
-if not self.__M540CaughtException or node is None:
-return
-for n in superwalk(node):
-if isinstance(n, ast.Name) and n.id == self.__M540CaughtException.name:
-self.__M540CaughtException = None
-break
-def __checkForM541(self, node):
-"""
-Private method to check for duplicate key value pairs in a dictionary literal.
-@param node reference to the node to be processed
-@type ast.Dict
-"""  # noqa: D-234r
-def convertToValue(item):
-"""
-Function to extract the value of a given item.
-@param item node to extract value from
-@type ast.Ast
-@return value of the node
-@rtype Any
-"""
-if isinstance(item, ast.Constant):
-return item.value
-elif isinstance(item, ast.Tuple):
-return tuple(convertToValue(i) for i in item.elts)
-elif isinstance(item, ast.Name):
-return M541VariableKeyType(item.id)
-else:
-return M541UnhandledKeyType()
-keys = [convertToValue(key) for key in node.keys]
-keyCounts = Counter(keys)
-duplicateKeys = [key for key, count in keyCounts.items() if count > 1]
-for key in duplicateKeys:
-keyIndices = [i for i, iKey in enumerate(keys) if iKey == key]
-seen = set()
-for index in keyIndices:
-value = convertToValue(node.values[index])
-if value in seen:
-keyNode = node.keys[index]
-self.violations.append((keyNode, "M-541"))
-seen.add(value)
-def __checkForM569(self, node):
-"""
-Private method to check for changes to a loop's mutable iterable.
-@param node loop node to be checked
-@type ast.For
-"""
-if isinstance(node.iter, ast.Name):
-name = self.toNameStr(node.iter)
-elif isinstance(node.iter, ast.Attribute):
-name = self.toNameStr(node.iter)
-else:
-return
-checker = M569Checker(name, self)
-checker.visit(node.body)
-for mutation in checker.mutations:
-self.violations.append((mutation, "M-569"))
-class M569Checker(ast.NodeVisitor):
-"""
-Class traversing a 'for' loop body to check for modifications to a loop's
-mutable iterable.
-"""
-# https://docs.python.org/3/library/stdtypes.html#mutable-sequence-types
-MUTATING_FUNCTIONS = (
-"append",
-"sort",
-"reverse",
-"remove",
-"clear",
-"extend",
-"insert",
-"pop",
-"popitem",
-)
-def __init__(self, name, bugbear):
-"""
-Constructor
-@param name name of the iterator
-@type str
-@param bugbear reference to the bugbear visitor
-@type BugBearVisitor
-"""
-self.__name = name
-self.__bb = bugbear
-self.mutations = []
-def visit_Delete(self, node):
-"""
-Public method handling 'Delete' nodes.
-@param node reference to the node to be processed
-@type ast.Delete
-"""
-for target in node.targets:
-if isinstance(target, ast.Subscript):
-name = self.__bb.toNameStr(target.value)
-elif isinstance(target, (ast.Attribute, ast.Name)):
-name = self.__bb.toNameStr(target)
-else:
-name = ""  # fallback
-self.generic_visit(target)
-if name == self.__name:
-self.mutations.append(node)
-def visit_Call(self, node):
-"""
-Public method handling 'Call' nodes.
-@param node reference to the node to be processed
-@type ast.Call
-"""
-if isinstance(node.func, ast.Attribute):
-name = self.__bb.toNameStr(node.func.value)
-functionObject = name
-functionName = node.func.attr
-if (
-functionObject == self.__name
-and functionName in self.MUTATING_FUNCTIONS
-):
-self.mutations.append(node)
-self.generic_visit(node)
-def visit(self, node):
-"""
-Public method to inspect an ast node.
-Like super-visit but supports iteration over lists.
-@param node AST node to be traversed
-@type TYPE
-@return reference to the last processed node
-@rtype ast.Node
-"""
-if not isinstance(node, list):
-return super().visit(node)
-for elem in node:
-super().visit(elem)
-return node
-class ExceptBaseExceptionVisitor(ast.NodeVisitor):
-"""
-Class to determine, if a 'BaseException' is re-raised.
-"""
-def __init__(self, exceptNode):
-"""
-Constructor
-@param exceptNode exception node to be inspected
-@type ast.ExceptHandler
-"""
-super().__init__()
-self.__root = exceptNode
-self.__reRaised = False
-def reRaised(self) -> bool:
-"""
-Public method to check, if the exception is re-raised.
-@return flag indicating a re-raised exception
-@rtype bool
-"""
-self.visit(self.__root)
-return self.__reRaised
-def visit_Raise(self, node):
-"""
-Public method to handle 'Raise' nodes.
-If we find a corresponding `raise` or `raise e` where e was from
-`except BaseException as e:` then we mark re_raised as True and can
-stop scanning.
-@param node reference to the node to be processed
-@type ast.Raise
-"""
-if node.exc is None or (
-isinstance(node.exc, ast.Name) and node.exc.id == self.__root.name
-):
-self.__reRaised = True
-return
-super().generic_visit(node)
-def visit_ExceptHandler(self, node: ast.ExceptHandler):
-"""
-Public method to handle 'ExceptHandler' nodes.
-@param node reference to the node to be processed
-@type ast.ExceptHandler
-"""
-if node is not self.__root:
-return  # entered a nested except - stop searching
-super().generic_visit(node)
-class NameFinder(ast.NodeVisitor):
-"""
-Class to extract a name out of a tree of nodes.
-"""
-def __init__(self):
-"""
-Constructor
-"""
-super().__init__()
-self.__names = {}
-def visit_Name(self, node):
-"""
-Public method to handle 'Name' nodes.
-@param node reference to the node to be processed
-@type ast.Name
-"""
-self.__names.setdefault(node.id, []).append(node)
-def visit(self, node):
-"""
-Public method to traverse a given AST node.
-@param node AST node to be traversed
-@type ast.Node
-@return reference to the last processed node
-@rtype ast.Node
-"""
-if isinstance(node, list):
-for elem in node:
-super().visit(elem)
-return node
-else:
-return super().visit(node)
-def getNames(self):
-"""
-Public method to return the extracted names and Name nodes.
-@return dictionary containing the names as keys and the list of nodes
-@rtype dict
-"""
-return self.__names
-class NamedExprFinder(ast.NodeVisitor):
-"""
-Class to extract names defined through an ast.NamedExpr.
-"""
-def __init__(self):
-"""
-Constructor
-"""
-super().__init__()
-self.__names = {}
-def visit_NamedExpr(self, node: ast.NamedExpr):
-"""
-Public method handling 'NamedExpr' nodes.
-@param node reference to the node to be processed
-@type ast.NamedExpr
-"""
-self.__names.setdefault(node.target.id, []).append(node.target)
-self.generic_visit(node)
-def visit(self, node):
-"""
-Public method to traverse a given AST node.
-Like super-visit but supports iteration over lists.
-@param node AST node to be traversed
-@type TYPE
-@return reference to the last processed node
-@rtype ast.Node
-"""
-if not isinstance(node, list):
-super().visit(node)
-for elem in node:
-super().visit(elem)
-return node
-def getNames(self):
-"""
-Public method to return the extracted names and Name nodes.
-@return dictionary containing the names as keys and the list of nodes
-@rtype dict
-"""
-return self.__names
-class FunctionDefDefaultsVisitor(ast.NodeVisitor):
-"""
-Class used by M506, M508 and M539.
-"""
-def __init__(
-self,
-errorCodeCalls,  # M506 or M539
-errorCodeLiterals,  # M508 or M539
-):
-"""
-Constructor
-@param errorCodeCalls error code for ast.Call nodes
-@type str
-@param errorCodeLiterals error code for literal nodes
-@type str
-"""
-self.__errorCodeCalls = errorCodeCalls
-self.__errorCodeLiterals = errorCodeLiterals
-for nodeType in BugbearMutableLiterals + BugbearMutableComprehensions:
-setattr(
-self, f"visit_{nodeType}", self.__visitMutableLiteralOrComprehension
-)
-self.errors = []
-self.__argDepth = 0
-super().__init__()
-def __visitMutableLiteralOrComprehension(self, node):
-"""
-Private method to flag mutable literals and comprehensions.
-@param node AST node to be processed
-@type ast.Dict, ast.List, ast.Set, ast.ListComp, ast.DictComp or ast.SetComp
-"""
-# Flag M506 if mutable literal/comprehension is not nested.
-# We only flag these at the top level of the expression as we
-# cannot easily guarantee that nested mutable structures are not
-# made immutable by outer operations, so we prefer no false positives.
-# e.g.
-# >>> def this_is_fine(a=frozenset({"a", "b", "c"})): ...
-#
-# >>> def this_is_not_fine_but_hard_to_detect(a=(lambda x: x)([1, 2, 3]))
-#
-# We do still search for cases of B008 within mutable structures though.
-if self.__argDepth == 1:
-self.errors.append((node, self.__errorCodeCalls))
-# Check for nested functions.
-self.generic_visit(node)
-def visit_Call(self, node):
-"""
-Public method to process Call nodes.
-@param node AST node to be processed
-@type ast.Call
-"""
-callPath = ".".join(composeCallPath(node.func))
-if callPath in BugbearMutableCalls:
-self.errors.append((node, self.__errorCodeCalls))
-self.generic_visit(node)
-return
-if callPath in BugbearImmutableCalls:
-self.generic_visit(node)
-return
-# Check if function call is actually a float infinity/NaN literal
-if callPath == "float" and len(node.args) == 1:
-try:
-value = float(ast.literal_eval(node.args[0]))
-except Exception:  # secok
-pass
-else:
-if math.isfinite(value):
-self.errors.append((node, self.__errorCodeLiterals))
-else:
-self.errors.append((node, self.__errorCodeLiterals))
-# Check for nested functions.
-self.generic_visit(node)
-def visit_Lambda(self, node):
-"""
-Public method to process Lambda nodes.
-@param node AST node to be processed
-@type ast.Lambda
-"""
-# Don't recurse into lambda expressions
-# as they are evaluated at call time.
-pass
-def visit(self, node):
-"""
-Public method to traverse an AST node or a list of AST nodes.
-This is an extended method that can also handle a list of AST nodes.
-@param node AST node or list of AST nodes to be processed
-@type ast.AST or list of ast.AST
-"""
-self.__argDepth += 1
-if isinstance(node, list):
-for elem in node:
-if elem is not None:
-super().visit(elem)
-else:
-super().visit(node)
-self.__argDepth -= 1
-class M520NameFinder(NameFinder):
-"""
-Class to extract a name out of a tree of nodes ignoring names defined within the
-local scope of a comprehension.
-"""
-def visit_GeneratorExp(self, node):
-"""
-Public method to handle a generator expressions.
-@param node reference to the node to be processed
-@type ast.GeneratorExp
-"""
-self.visit(node.generators)
-def visit_ListComp(self, node):
-"""
-Public method  to handle a list comprehension.
-@param node reference to the node to be processed
-@type TYPE
-"""
-self.visit(node.generators)
-def visit_DictComp(self, node):
-"""
-Public method  to handle a dictionary comprehension.
-@param node reference to the node to be processed
-@type TYPE
-"""
-self.visit(node.generators)
-def visit_comprehension(self, node):
-"""
-Public method  to handle the 'for' of a comprehension.
-@param node reference to the node to be processed
-@type ast.comprehension
-"""
-self.visit(node.iter)
-def visit_Lambda(self, node):
-"""
-Public method  to handle a Lambda function.
-@param node reference to the node to be processed
-@type ast.Lambda
-"""
-self.visit(node.body)
-for lambdaArg in node.args.args:
-self.getNames().pop(lambdaArg.arg, None)
-class ReturnVisitor(ast.NodeVisitor):
-"""
-Class implementing a node visitor to check return statements.
-"""
-Assigns = "assigns"
-Refs = "refs"
-Returns = "returns"
-def __init__(self):
-"""
-Constructor
-"""
-super().__init__()
-self.__stack = []
-self.violations = []
-self.__loopCount = 0
-@property
-def assigns(self):
-"""
-Public method to get the Assign nodes.
-@return dictionary containing the node name as key and line number
-as value
-@rtype dict
-"""
-return self.__stack[-1][ReturnVisitor.Assigns]
-@property
-def refs(self):
-"""
-Public method to get the References nodes.
-@return dictionary containing the node name as key and line number
-as value
-@rtype dict
-"""
-return self.__stack[-1][ReturnVisitor.Refs]
-@property
-def returns(self):
-"""
-Public method to get the Return nodes.
-@return dictionary containing the node name as key and line number
-as value
-@rtype dict
-"""
-return self.__stack[-1][ReturnVisitor.Returns]
-def visit_For(self, node):
-"""
-Public method to handle a for loop.
-@param node reference to the for node to handle
-@type ast.For
-"""
-self.__visitLoop(node)
-def visit_AsyncFor(self, node):
-"""
-Public method to handle an async for loop.
-@param node reference to the async for node to handle
-@type ast.AsyncFor
-"""
-self.__visitLoop(node)
-def visit_While(self, node):
-"""
-Public method to handle a while loop.
-@param node reference to the while node to handle
-@type ast.While
-"""
-self.__visitLoop(node)
-def __visitLoop(self, node):
-"""
-Private method to handle loop nodes.
-@param node reference to the loop node to handle
-@type ast.For, ast.AsyncFor or ast.While
-"""
-self.__loopCount += 1
-self.generic_visit(node)
-self.__loopCount -= 1
-def __visitWithStack(self, node):
-"""
-Private method to traverse a given function node using a stack.
-@param node AST node to be traversed
-@type ast.FunctionDef or ast.AsyncFunctionDef
-"""
-self.__stack.append(
-{
-ReturnVisitor.Assigns: defaultdict(list),
-ReturnVisitor.Refs: defaultdict(list),
-ReturnVisitor.Returns: [],
-}
-)
-self.generic_visit(node)
-self.__checkFunction(node)
-self.__stack.pop()
-def visit_FunctionDef(self, node):
-"""
-Public method to handle a function definition.
-@param node reference to the node to handle
-@type ast.FunctionDef
-"""
-self.__visitWithStack(node)
-def visit_AsyncFunctionDef(self, node):
-"""
-Public method to handle a function definition.
-@param node reference to the node to handle
-@type ast.AsyncFunctionDef
-"""
-self.__visitWithStack(node)
-def visit_Return(self, node):
-"""
-Public method to handle a return node.
-@param node reference to the node to handle
-@type ast.Return
-"""
-self.returns.append(node)
-self.generic_visit(node)
-def visit_Assign(self, node):
-"""
-Public method to handle an assign node.
-@param node reference to the node to handle
-@type ast.Assign
-"""
-if not self.__stack:
-return
-self.generic_visit(node.value)
-target = node.targets[0]
-if isinstance(target, ast.Tuple) and not isinstance(node.value, ast.Tuple):
-# skip unpacking assign
-return
-self.__visitAssignTarget(target)
-def visit_Name(self, node):
-"""
-Public method to handle a name node.
-@param node reference to the node to handle
-@type ast.Name
-"""
-if self.__stack:
-self.refs[node.id].append(node.lineno)
-def __visitAssignTarget(self, node):
-"""
-Private method to handle an assign target node.
-@param node reference to the node to handle
-@type ast.AST
-"""
-if isinstance(node, ast.Tuple):
-for elt in node.elts:
-self.__visitAssignTarget(elt)
-return
-if not self.__loopCount and isinstance(node, ast.Name):
-self.assigns[node.id].append(node.lineno)
-return
-self.generic_visit(node)
-def __checkFunction(self, node):
-"""
-Private method to check a function definition node.
-@param node reference to the node to check
-@type ast.AsyncFunctionDef or ast.FunctionDef
-"""
-if not self.returns or not node.body:
-return
-if len(node.body) == 1 and isinstance(node.body[-1], ast.Return):
-# skip functions that consist of `return None` only
-return
-if not self.__resultExists():
-self.__checkUnnecessaryReturnNone()
-return
-self.__checkImplicitReturnValue()
-self.__checkImplicitReturn(node.body[-1])
-for n in self.returns:
-if n.value:
-self.__checkUnnecessaryAssign(n.value)
-def __isNone(self, node):
-"""
-Private method to check, if a node value is None.
-@param node reference to the node to check
-@type ast.AST
-@return flag indicating the node contains a None value
-@rtype bool
-"""
-return AstUtilities.isNameConstant(node) and AstUtilities.getValue(node) is None
-def __isFalse(self, node):
-"""
-Private method to check, if a node value is False.
-@param node reference to the node to check
-@type ast.AST
-@return flag indicating the node contains a False value
-@rtype bool
-"""
-return (
-AstUtilities.isNameConstant(node) and AstUtilities.getValue(node) is False
-)
-def __resultExists(self):
-"""
-Private method to check the existance of a return result.
-@return flag indicating the existence of a return result
-@rtype bool
-"""
-for node in self.returns:
-value = node.value
-if value and not self.__isNone(value):
-return True
-return False
-def __checkImplicitReturnValue(self):
-"""
-Private method to check for implicit return values.
-"""
-for node in self.returns:
-if not node.value:
-self.violations.append((node, "M-832"))
-def __checkUnnecessaryReturnNone(self):
-"""
-Private method to check for an unnecessary 'return None' statement.
-"""
-for node in self.returns:
-if self.__isNone(node.value):
-self.violations.append((node, "M-831"))
-def __checkImplicitReturn(self, node):
-"""
-Private method to check for an implicit return statement.
-@param node reference to the node to check
-@type ast.AST
-"""
-if isinstance(node, ast.If):
-if not node.body or not node.orelse:
-self.violations.append((node, "M-833"))
-return
-self.__checkImplicitReturn(node.body[-1])
-self.__checkImplicitReturn(node.orelse[-1])
-return
-if isinstance(node, (ast.For, ast.AsyncFor)) and node.orelse:
-self.__checkImplicitReturn(node.orelse[-1])
-return
-if isinstance(node, (ast.With, ast.AsyncWith)):
-self.__checkImplicitReturn(node.body[-1])
-return
-if isinstance(node, ast.Assert) and self.__isFalse(node.test):
-return
-try:
-okNodes = (ast.Return, ast.Raise, ast.While, ast.Try)
-except AttributeError:
-okNodes = (ast.Return, ast.Raise, ast.While)
-if not isinstance(node, okNodes):
-self.violations.append((node, "M-833"))
-def __checkUnnecessaryAssign(self, node):
-"""
-Private method to check for an unnecessary assign statement.
-@param node reference to the node to check
-@type ast.AST
-"""
-if not isinstance(node, ast.Name):
-return
-varname = node.id
-returnLineno = node.lineno
-if varname not in self.assigns:
-return
-if varname not in self.refs:
-self.violations.append((node, "M-834"))
-return
-if self.__hasRefsBeforeNextAssign(varname, returnLineno):
-return
-self.violations.append((node, "M-834"))
-def __hasRefsBeforeNextAssign(self, varname, returnLineno):
-"""
-Private method to check for references before a following assign
-statement.
-@param varname variable name to check for
-@type str
-@param returnLineno line number of the return statement
-@type int
-@return flag indicating the existence of references
-@rtype bool
-"""
-beforeAssign = 0
-afterAssign = None
-for lineno in sorted(self.assigns[varname]):
-if lineno > returnLineno:
-afterAssign = lineno
-break
-if lineno <= returnLineno:
-beforeAssign = lineno
-for lineno in self.refs[varname]:
-if lineno == returnLineno:
-continue
-if afterAssign:
-if beforeAssign < lineno <= afterAssign:
-return True
-elif beforeAssign < lineno:
-return True
-return False
-class DateTimeVisitor(ast.NodeVisitor):
-"""
-Class implementing a node visitor to check datetime function calls.
-Note: This class is modeled after flake8_datetimez checker.
-"""
-def __init__(self):
-"""
-Constructor
-"""
-super().__init__()
-self.violations = []
-def __getFromKeywords(self, keywords, name):
-"""
-Private method to get a keyword node given its name.
-@param keywords list of keyword argument nodes
-@type list of ast.AST
-@param name name of the keyword node
-@type str
-@return keyword node
-@rtype ast.AST
-"""
-for keyword in keywords:
-if keyword.arg == name:
-return keyword
-return None
-def visit_Call(self, node):
-"""
-Public method to handle a function call.
-Every datetime related function call is check for use of the naive
-variant (i.e. use without TZ info).
-@param node reference to the node to be processed
-@type ast.Call
-"""
-# datetime.something()
-isDateTimeClass = (
-isinstance(node.func, ast.Attribute)
-and isinstance(node.func.value, ast.Name)
-and node.func.value.id == "datetime"
-)
-# datetime.datetime.something()
-isDateTimeModuleAndClass = (
-isinstance(node.func, ast.Attribute)
-and isinstance(node.func.value, ast.Attribute)
-and node.func.value.attr == "datetime"
-and isinstance(node.func.value.value, ast.Name)
-and node.func.value.value.id == "datetime"
-)
-if isDateTimeClass:
-if node.func.attr == "datetime":
-# datetime.datetime(2000, 1, 1, 0, 0, 0, 0,
-#                   datetime.timezone.utc)
-isCase1 = len(node.args) >= 8 and not (
-AstUtilities.isNameConstant(node.args[7])
-and AstUtilities.getValue(node.args[7]) is None
-)
-# datetime.datetime(2000, 1, 1, tzinfo=datetime.timezone.utc)
-tzinfoKeyword = self.__getFromKeywords(node.keywords, "tzinfo")
-isCase2 = tzinfoKeyword is not None and not (
-AstUtilities.isNameConstant(tzinfoKeyword.value)
-and AstUtilities.getValue(tzinfoKeyword.value) is None
-)
-if not (isCase1 or isCase2):
-self.violations.append((node, "M-301"))
-elif node.func.attr == "time":
-# time(12, 10, 45, 0, datetime.timezone.utc)
-isCase1 = len(node.args) >= 5 and not (
-AstUtilities.isNameConstant(node.args[4])
-and AstUtilities.getValue(node.args[4]) is None
-)
-# datetime.time(12, 10, 45, tzinfo=datetime.timezone.utc)
-tzinfoKeyword = self.__getFromKeywords(node.keywords, "tzinfo")
-isCase2 = tzinfoKeyword is not None and not (
-AstUtilities.isNameConstant(tzinfoKeyword.value)
-and AstUtilities.getValue(tzinfoKeyword.value) is None
-)
-if not (isCase1 or isCase2):
-self.violations.append((node, "M-321"))
-elif node.func.attr == "date":
-self.violations.append((node, "M-311"))
-if isDateTimeClass or isDateTimeModuleAndClass:
-if node.func.attr == "today":
-self.violations.append((node, "M-302"))
-elif node.func.attr == "utcnow":
-self.violations.append((node, "M-303"))
-elif node.func.attr == "utcfromtimestamp":
-self.violations.append((node, "M-304"))
-elif node.func.attr in "now":
-# datetime.now(UTC)
-isCase1 = (
-len(node.args) == 1
-and len(node.keywords) == 0
-and not (
-AstUtilities.isNameConstant(node.args[0])
-and AstUtilities.getValue(node.args[0]) is None
-)
-)
-# datetime.now(tz=UTC)
-tzKeyword = self.__getFromKeywords(node.keywords, "tz")
-isCase2 = tzKeyword is not None and not (
-AstUtilities.isNameConstant(tzKeyword.value)
-and AstUtilities.getValue(tzKeyword.value) is None
-)
-if not (isCase1 or isCase2):
-self.violations.append((node, "M-305"))
-elif node.func.attr == "fromtimestamp":
-# datetime.fromtimestamp(1234, UTC)
-isCase1 = (
-len(node.args) == 2
-and len(node.keywords) == 0
-and not (
-AstUtilities.isNameConstant(node.args[1])
-and AstUtilities.getValue(node.args[1]) is None
-)
-)
-# datetime.fromtimestamp(1234, tz=UTC)
-tzKeyword = self.__getFromKeywords(node.keywords, "tz")
-isCase2 = tzKeyword is not None and not (
-AstUtilities.isNameConstant(tzKeyword.value)
-and AstUtilities.getValue(tzKeyword.value) is None
-)
-if not (isCase1 or isCase2):
-self.violations.append((node, "M-306"))
-elif node.func.attr == "strptime":
-# datetime.strptime(...).replace(tzinfo=UTC)
-parent = getattr(node, "_dtCheckerParent", None)
-pparent = getattr(parent, "_dtCheckerParent", None)
-if not (
-isinstance(parent, ast.Attribute) and parent.attr == "replace"
-) or not isinstance(pparent, ast.Call):
-isCase1 = False
-else:
-tzinfoKeyword = self.__getFromKeywords(pparent.keywords, "tzinfo")
-isCase1 = tzinfoKeyword is not None and not (
-AstUtilities.isNameConstant(tzinfoKeyword.value)
-and AstUtilities.getValue(tzinfoKeyword.value) is None
-)
-if not isCase1:
-self.violations.append((node, "M-307"))
-elif node.func.attr == "fromordinal":
-self.violations.append((node, "M-308"))
-# date.something()
-isDateClass = (
-isinstance(node.func, ast.Attribute)
-and isinstance(node.func.value, ast.Name)
-and node.func.value.id == "date"
-)
-# datetime.date.something()
-isDateModuleAndClass = (
-isinstance(node.func, ast.Attribute)
-and isinstance(node.func.value, ast.Attribute)
-and node.func.value.attr == "date"
-and isinstance(node.func.value.value, ast.Name)
-and node.func.value.value.id == "datetime"
-)
-if isDateClass or isDateModuleAndClass:
-if node.func.attr == "today":
-self.violations.append((node, "M-312"))
-elif node.func.attr == "fromtimestamp":
-self.violations.append((node, "M-313"))
-elif node.func.attr == "fromordinal":
-self.violations.append((node, "M-314"))
-elif node.func.attr == "fromisoformat":
-self.violations.append((node, "M-315"))
-self.generic_visit(node)
-class SysVersionVisitor(ast.NodeVisitor):
-"""
-Class implementing a node visitor to check the use of sys.version and
-sys.version_info.
-Note: This class is modeled after flake8-2020 v1.8.1.
-"""
-def __init__(self):
-"""
-Constructor
-"""
-super().__init__()
-self.violations = []
-self.__fromImports = {}
-def visit_ImportFrom(self, node):
-"""
-Public method to handle a from ... import ... statement.
-@param node reference to the node to be processed
-@type ast.ImportFrom
-"""
-for alias in node.names:
-if node.module is not None and not alias.asname:
-self.__fromImports[alias.name] = node.module
-self.generic_visit(node)
-def __isSys(self, attr, node):
-"""
-Private method to check for a reference to sys attribute.
-@param attr attribute name
-@type str
-@param node reference to the node to be checked
-@type ast.Node
-@return flag indicating a match
-@rtype bool
-"""
-match = False
-if (
-isinstance(node, ast.Attribute)
-and isinstance(node.value, ast.Name)
-and node.value.id == "sys"
-and node.attr == attr
-) or (
-isinstance(node, ast.Name)
-and node.id == attr
-and self.__fromImports.get(node.id) == "sys"
-):
-match = True
-return match
-def __isSysVersionUpperSlice(self, node, n):
-"""
-Private method to check the upper slice of sys.version.
-@param node reference to the node to be checked
-@type ast.Node
-@param n slice value to check against
-@type int
-@return flag indicating a match
-@rtype bool
-"""
-return (
-self.__isSys("version", node.value)
-and isinstance(node.slice, ast.Slice)
-and node.slice.lower is None
-and AstUtilities.isNumber(node.slice.upper)
-and AstUtilities.getValue(node.slice.upper) == n
-and node.slice.step is None
-)
-def visit_Subscript(self, node):
-"""
-Public method to handle a subscript.
-@param node reference to the node to be processed
-@type ast.Subscript
-"""
-if self.__isSysVersionUpperSlice(node, 1):
-self.violations.append((node.value, "M-423"))
-elif self.__isSysVersionUpperSlice(node, 3):
-self.violations.append((node.value, "M-401"))
-elif (
-self.__isSys("version", node.value)
-and isinstance(node.slice, ast.Index)
-and AstUtilities.isNumber(node.slice.value)
-and AstUtilities.getValue(node.slice.value) == 2
-):
-self.violations.append((node.value, "M-402"))
-elif (
-self.__isSys("version", node.value)
-and isinstance(node.slice, ast.Index)
-and AstUtilities.isNumber(node.slice.value)
-and AstUtilities.getValue(node.slice.value) == 0
-):
-self.violations.append((node.value, "M-421"))
-self.generic_visit(node)
-def visit_Compare(self, node):
-"""
-Public method to handle a comparison.
-@param node reference to the node to be processed
-@type ast.Compare
-"""
-if (
-isinstance(node.left, ast.Subscript)
-and self.__isSys("version_info", node.left.value)
-and isinstance(node.left.slice, ast.Index)
-and AstUtilities.isNumber(node.left.slice.value)
-and AstUtilities.getValue(node.left.slice.value) == 0
-and len(node.ops) == 1
-and isinstance(node.ops[0], ast.Eq)
-and AstUtilities.isNumber(node.comparators[0])
-and AstUtilities.getValue(node.comparators[0]) == 3
-):
-self.violations.append((node.left, "M-411"))
-elif (
-self.__isSys("version", node.left)
-and len(node.ops) == 1
-and isinstance(node.ops[0], (ast.Lt, ast.LtE, ast.Gt, ast.GtE))
-and AstUtilities.isString(node.comparators[0])
-):
-if len(AstUtilities.getValue(node.comparators[0])) == 1:
-errorCode = "M-422"
-else:
-errorCode = "M-403"
-self.violations.append((node.left, errorCode))
-elif (
-isinstance(node.left, ast.Subscript)
-and self.__isSys("version_info", node.left.value)
-and isinstance(node.left.slice, ast.Index)
-and AstUtilities.isNumber(node.left.slice.value)
-and AstUtilities.getValue(node.left.slice.value) == 1
-and len(node.ops) == 1
-and isinstance(node.ops[0], (ast.Lt, ast.LtE, ast.Gt, ast.GtE))
-and AstUtilities.isNumber(node.comparators[0])
-):
-self.violations.append((node, "M-413"))
-elif (
-isinstance(node.left, ast.Attribute)
-and self.__isSys("version_info", node.left.value)
-and node.left.attr == "minor"
-and len(node.ops) == 1
-and isinstance(node.ops[0], (ast.Lt, ast.LtE, ast.Gt, ast.GtE))
-and AstUtilities.isNumber(node.comparators[0])
-):
-self.violations.append((node, "M-414"))
-self.generic_visit(node)
-def visit_Attribute(self, node):
-"""
-Public method to handle an attribute.
-@param node reference to the node to be processed
-@type ast.Attribute
-"""
-if (
-isinstance(node.value, ast.Name)
-and node.value.id == "six"
-and node.attr == "PY3"
-):
-self.violations.append((node, "M-412"))
-self.generic_visit(node)
-def visit_Name(self, node):
-"""
-Public method to handle an name.
-@param node reference to the node to be processed
-@type ast.Name
-"""
-if node.id == "PY3" and self.__fromImports.get(node.id) == "six":
-self.violations.append((node, "M-412"))
-self.generic_visit(node)
-class DefaultMatchCaseVisitor(ast.NodeVisitor):
-"""
-Class implementing a node visitor to check default match cases.
-Note: This class is modeled after flake8-spm v0.0.1.
-"""
-def __init__(self):
-"""
-Constructor
-"""
-super().__init__()
-self.violations = []
-def visit_Match(self, node):
-"""
-Public method to handle Match nodes.
-@param node reference to the node to be processed
-@type ast.Match
-"""
-for badNode, issueCode in self.__badNodes(node):
-self.violations.append((badNode, issueCode))
-self.generic_visit(node)
-def __badNodes(self, node):
-"""
-Private method to yield bad match nodes.
-@param node reference to the node to be processed
-@type ast.Match
-@yield tuple containing a reference to bad match case node and the corresponding
-issue code
-@ytype tyuple of (ast.AST, str)
-"""
-for case in node.cases:
-if self.__emptyMatchDefault(case):
-if self.__lastStatementDoesNotRaise(case):
-yield self.__findBadNode(case), "M-901"
-elif self.__returnPrecedesExceptionRaising(case):
-yield self.__findBadNode(case), "M-902"
-def __emptyMatchDefault(self, case):
-"""
-Private method to check for an empty default match case.
-@param case reference to the node to be processed
-@type ast.match_case
-@return flag indicating an empty default match case
-@rtype bool
-"""
-pattern = case.pattern
-return isinstance(pattern, ast.MatchAs) and (
-pattern.pattern is None
-or (
-isinstance(pattern.pattern, ast.MatchAs)
-and pattern.pattern.pattern is None
-)
-)
-def __lastStatementDoesNotRaise(self, case):
-"""
-Private method to check that the last case statement does not raise an
-exception.
-@param case reference to the node to be processed
-@type ast.match_case
-@return flag indicating that the last case statement does not raise an
-exception
-@rtype bool
-"""
-return not isinstance(case.body[-1], ast.Raise)
-def __returnPrecedesExceptionRaising(self, case):
-"""
-Private method to check that no return precedes an exception raising.
-@param case reference to the node to be processed
-@type ast.match_case
-@return flag indicating that a return precedes an exception raising
-@rtype bool
-"""
-returnIndex = -1
-raiseIndex = -1
-for index, body in enumerate(case.body):
-if isinstance(body, ast.Return):
-returnIndex = index
-elif isinstance(body, ast.Raise):
-raiseIndex = index
-return returnIndex >= 0 and returnIndex < raiseIndex
-def __findBadNode(self, case) -> ast.AST:
-"""
-Private method returning a reference to the bad node of a case node.
-@param case reference to the node to be processed
-@type ast.match_case
-@return reference to the bad node
-@rtype ast.AST
-"""
-for body in case.body:
-# Handle special case when return precedes exception raising.
-# In this case the bad node is that with the return statement.
-if isinstance(body, ast.Return):
-return body
-return case.body[-1]
-#
-# eflag: noqa = M-891

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Miscellaneous/MiscellaneousChecker.py

src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Miscellaneous/MiscellaneousChecker.py