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

-:a90284948331
+:1f743bad6fd3
 import math
 import re
 import sys
 import tokenize
-from collections import defaultdict, namedtuple
+from collections import Counter, defaultdict, namedtuple
 from dataclasses import dataclass
 from keyword import iskeyword
 from string import Formatter
 try:
 "M535",
 "M536",
 "M537",
 "M539",
 "M540",
+"M541",
 ## Bugbear, opininonated
 "M569",
 ## Bugbear++
 "M581",
 "M582",
 "M535",
 "M536",
 "M537",
 "M539",
 "M540",
+"M541",
 "M569",
 "M581",
 "M582",
 ),
 ),
 #######################################################################
 ## BugBearVisitor
 ##
-## adapted from: flake8-bugbear v24.8.19
+## adapted from: flake8-bugbear v24.12.12
 ##
 ## Original: Copyright (c) 2016 Łukasz Langa
 #######################################################################
 BugBearContext = namedtuple("BugBearContext", ["node", "stack"])
 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.
 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.
 ):
 exprList.extend(expr.value.elts)
 continue
 yield expr
-def __checkRedundantExcepthandlers(self, names, node):
+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": {
 ):
 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, "M514", ", ".join(names), as_, desc)
+return (node, "M514", ", ".join(names), as_, desc, inTryStar)
 return None
 def __walkList(self, nodes):
 """
 if node.name is None:
 self.__M540CaughtException = None
 else:
 self.__M540CaughtException = M540CaughtException(node.name, False)
-names = self.__checkForM513_M529_M530(node)
+names = self.__checkForM513_M514_M529_M530(node)
 if "BaseException" in names and not ExceptBaseExceptionVisitor(node).reRaised():
 self.violations.append((node, "M536"))
 self.generic_visit(node)
 self.generic_visit(node)
 def visit_Try(self, node):
 """
-Public method to handle 'try' statements'.
+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.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):
 """
 if isinstance(node, (ast.While, ast.For)):
 badNodeTypes = (ast.Return,)
 elif isinstance(node, badNodeTypes):
-self.violations.append((node, "M512"))
+self.violations.append((node, "M512", 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_M529_M530(self, node):
+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
 else:
 badHandlers.append(handler)
 if badHandlers:
 self.violations.append((node, "M530"))
 if len(names) == 0 and not badHandlers and not ignoredHandlers:
-self.violations.append((node, "M529"))
+self.violations.append((node, "M529", self.__inTryStar))
 elif (
 len(names) == 1
 and not badHandlers
 and not ignoredHandlers
 and isinstance(node.type, ast.Tuple)
 ):
-self.violations.append((node, "M513", *names))
+self.violations.append((node, "M513", *names, self.__inTryStar))
 else:
-maybeError = self.__checkRedundantExcepthandlers(names, node)
+maybeError = self.__checkRedundantExcepthandlers(
+names, node, self.__inTryStar
+)
 if maybeError is not None:
 self.violations.append(maybeError)
 return names
 def __checkForM515(self, node):
 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, ast.Assign)):
+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)):
 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, "M525", duplicate))
+self.violations.append((node, "M525", duplicate, self.__inTryStar))
 def __checkForM526(self, node):
 """
 Private method to check for Star-arg unpacking after keyword argument.
 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, "M528"))
 def __checkForM531(self, loopNode):
 """
 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: D234r
+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, "M541"))
+seen.add(value)
 def __checkForM569(self, node):
 """
 Private method to check for changes to a loop's mutable iterable.

Mercurial Repositories > eric / file comparison

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

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