eric: comparison src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Simplify/SimplifyNodeVisitor.py

-:471c5a263d53
+:36448ca469c2
 self.__check206(node)
 self.__check207(node)
 self.__check208(node)
 self.generic_visit(node)
 def visit_Subscript(self, node):
 """
 Public method to process a Subscript node.
 @param node reference to the Subscript node
 return [name for name, count in counter.items() if count > 1]
 def __isConstantIncrease(self, expr):
 """
 Private method to check an expression for being a constant increase.
 @param expr reference to the node to be checked
 @type ast.AugAssign
 @return flag indicating a constant increase
 @rtype bool
 """
 return isinstance(expr.op, ast.Add) and (
-(
+(isinstance(expr.value, ast.Constant) and expr.value.value == 1)
-isinstance(expr.value, ast.Constant)
-and expr.value.value == 1
-)
 or (isinstance(expr.value, ast.Num) and expr.value.n == 1)
 )
 def __getIfBodyPairs(self, node):
 """
 return newNode
 def __expressionUsesVariable(self, expr, var):
 """
 Private method to check, if a variable is used by an expression.
 @param expr expression node to be checked
 @type ast.expr
 @param var variable name to be checked for
 @type str
 @return flag indicating the expression uses the variable
 # false-positives.
 def __bodyContainsContinue(self, stmts):
 """
 Private method to check, if a list of statements contain a 'continue' statement.
 @param stmts list of statements
 @type list of ast.stmt
 @return flag indicating a continue statement
 @rtype bool
 """
 if isinstance(stmt, ast.Return):
 finallyHasReturn = True
 finallyReturn = stmt
 break
-if (
+if (tryHasReturn or exceptHasReturn) and finallyHasReturn:
-(tryHasReturn or exceptHasReturn)
-and finallyHasReturn
-):
 self.__error(finallyReturn.lineno - 1, finallyReturn.col_offset, "Y107")
 def __check108(self, node):
 """
 Private method to check for if-elses which could be a ternary
 and node.body[0].targets[0].id == node.orelse[0].targets[0].id
 and not isinstance(node.parent, ast.If)
 ):
 targetVar = node.body[0].targets[0]
 assign = unparse(targetVar)
 # It's part of a bigger if-elseif block:
 if isinstance(node.parent, ast.If):
 for n in node.parent.body:
 if (
 isinstance(n, ast.Assign)
 and isinstance(n.targets[0], ast.Name)
 and n.targets[0].id == targetVar.id
 ):
 return
 body = unparse(node.body[0].value)
 cond = unparse(node.test)
 orelse = unparse(node.orelse[0].value)
 self.__error(
 if isCompoundExpression:
 check = f"not ({check})"
 else:
 if check.startswith("not "):
-check = check[len("not "):]
+check = check[len("not ") :]
 else:
 check = f"not {check}"
 self.__error(
 node.lineno - 1, node.col_offset, "Y111", check, target, iterable
 )
 while sibling is not None:
 sibling = sibling.previous_sibling
 for match in matches:
 variable = unparse(match)
-self.__error(
+self.__error(match.lineno - 1, match.col_offset, "Y113", variable)
-match.lineno - 1, match.col_offset, "Y113", variable
-)
 def __check114(self, node):
 """
 Private method to check for alternative if clauses with identical
 bodies.
 else:
 bodyValueStr = "None"
 if isinstance(node.test.comparators[0], ast.Str):
 value = (
 bodyValueStr
-if bodyValueStr[0] == '"' and bodyValueStr[-1] == '"' else
+if bodyValueStr[0] == '"' and bodyValueStr[-1] == '"'
-bodyValueStr[1:-1]
+else bodyValueStr[1:-1]
 )
 keyValuePairs = {node.test.comparators[0].s: value}
 elif isinstance(node.test.comparators[0], ast.Num):
 keyValuePairs = {node.test.comparators[0].n: bodyValueStr}
 else:
 self.__error(node.lineno - 1, node.col_offset, "Y122", dictname, key)
 def __check123(self, node):
 """
 Private method to check for complicated dictionary access with default value.
 @param node reference to the AST node to be checked
 @type ast.If
 """
 isPattern1 = (
 len(node.body) == 1
 dictStr = unparse(dictName)
 defaultStr = unparse(defaultValue)
 valueStr = unparse(valueNode)
 else:
 return
-self.__error(node.lineno - 1, node.col_offset, "Y123", valueStr, dictStr,
+self.__error(
-keyStr, defaultStr)
+node.lineno - 1,
+node.col_offset,
+"Y123",
+valueStr,
+dictStr,
+keyStr,
+defaultStr,
+)
 def __check181(self, node):
 """
 Private method to check for assignments that could be converted into
 an augmented assignment.
 self.__error(node.lineno - 1, node.col_offset, "Y402")
 def __check901(self, node):
 """
 Private method to check for unnecessary bool conversion.
 @param node reference to the AST node to be checked
 @type ast.Call
 """
 if (
 isinstance(node.func, ast.Name)
 self.__error(node.lineno - 1, node.col_offset, "Y901", expected, actual)
 def __check904(self, node):
 """
 Private method to check for dictionary initialization.
 @param node reference to the AST node to be checked
 @type ast.Assign
 """
 # a = {}; a['b'] = 'c'
 n2 = node.next_sibling
 self.__error(node.lineno - 1, node.col_offset, "Y904", dictName)
 def __check905(self, node):
 """
 Private method to check for list initialization by splitting a string.
 @param node reference to the AST node to be checked
 @type ast.Call
 """
 if (
 isinstance(node.func, ast.Attribute)
 self.__error(node.lineno - 1, node.col_offset, "Y905", expected, actual)
 def __check906(self, node):
 """
 Private method to check for unnecessary nesting of os.path.join().
 @param node reference to the AST node to be checked
 @type ast.Call
 """
 # __IGNORE_WARNING_D234r__
 def getOsPathJoinArgs(node):
 )
 ):
 names = getOsPathJoinArgs(node)
 actual = unparse(node)
-expected = "os.path.join({0})".format(', '.join(names))
+expected = "os.path.join({0})".format(", ".join(names))
 self.__error(node.lineno - 1, node.col_offset, "Y906", expected, actual)
 def __check907(self, node):
 """
 Private method to check for Union type annotation with None.
 @param node reference to the AST node to be checked
 @type ast.Subscript
 """
-if (isinstance(node.value, ast.Name) and node.value.id == "Union"):
+if isinstance(node.value, ast.Name) and node.value.id == "Union":
-if (
+if isinstance(node.slice, ast.Index) and isinstance(
-isinstance(node.slice, ast.Index)
+node.slice.value, ast.Tuple
-and isinstance(node.slice.value, ast.Tuple)
 ):
 # Python 3.8
 tupleVar = node.slice.value
 elif isinstance(node.slice, ast.Tuple):
 # Python 3.9+
 )
 def __check909(self, node):
 """
 Private method to check for reflexive assignments.
 @param node reference to the AST node to be checked
 @type ast.Assign
 """
 names = []
 if isinstance(node.value, (ast.Name, ast.Subscript, ast.Tuple)):
 if len(names) != len(set(names)) and not isinstance(node.parent, ast.ClassDef):
 srccode = unparse(node)
 self.__error(node.lineno - 1, node.col_offset, "Y909", srccode)
 #
 # eflag: noqa = M891

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Simplify/SimplifyNodeVisitor.py

src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Simplify/SimplifyNodeVisitor.py