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

-:8312e0e76795
+:0f70a4ef4592
 try:
 from ast import unparse
 except ImportError:
 # Python < 3.9
 from ast_unparse import unparse
+import AstUtilities
 ###############################################################################
 ## The following code is derived from the flake8-simplify package (v0.20.0).
 ##
 ## Original License:
 ## LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 ## FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 ## IN THE SOFTWARE.
 ###############################################################################
-BOOL_CONST_TYPES = (ast.Constant, ast.NameConstant)
-AST_CONST_TYPES = (ast.Constant, ast.NameConstant, ast.Str, ast.Num)
-STR_TYPES = (ast.Constant, ast.Str)
 class SimplifyNodeVisitor(ast.NodeVisitor):
 """
 Class to traverse the AST node tree and check for code that can be
 simplified.
 @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)
-or (isinstance(expr.value, ast.Num) and expr.value.n == 1)
 )
 def __getIfBodyPairs(self, node):
 """
 Private method to extract a list of pairs of test and body for an
 # else:
 #     return False
 if not (
 len(node.body) != 1
 or not isinstance(node.body[0], ast.Return)
-or not isinstance(node.body[0].value, BOOL_CONST_TYPES)
+or not isinstance(node.body[0].value, ast.Constant)
 or not (
 node.body[0].value.value is True or node.body[0].value.value is False
 )
 or len(node.orelse) != 1
 or not isinstance(node.orelse[0], ast.Return)
-or not isinstance(node.orelse[0].value, BOOL_CONST_TYPES)
+or not isinstance(node.orelse[0].value, ast.Constant)
 or not (
 node.orelse[0].value.value is True
 or node.orelse[0].value.value is False
 )
 ):
 if (
 len(node.body) == 1
 and isinstance(node.body[0], ast.If)
 and len(node.body[0].body) == 1
 and isinstance(node.body[0].body[0], ast.Return)
-and isinstance(node.body[0].body[0].value, BOOL_CONST_TYPES)
+and isinstance(node.body[0].body[0].value, ast.Constant)
 and hasattr(node.body[0].body[0].value, "value")
 and isinstance(node.next_sibling, ast.Return)
 ):
 check = unparse(node.body[0].test)
 target = unparse(node.target)
 and node.value.value.value.id == "os"
 and node.value.value.attr == "environ"
 and (
 (
 isinstance(node.value.slice, ast.Index)
-and isinstance(node.value.slice.value, STR_TYPES)
+and isinstance(node.value.slice.value, ast.Constant)
 )
 or isinstance(node.value.slice, ast.Constant)
 )
 )
 if isIndexCall:
 subscript = node.value
 slice_ = subscript.slice
 if isinstance(slice_, ast.Index):
 # Python < 3.9
 stringPart = slice_.value  # type: ignore
-if isinstance(stringPart, ast.Str):
+envName = stringPart.value
-envName = stringPart.s  # Python 3.6 / 3.7 fallback
-else:
-envName = stringPart.value
 elif isinstance(slice_, ast.Constant):
 # Python 3.9
 envName = slice_.value
 # Check if this has a change
 and isinstance(node.value.func.value.value, ast.Name)
 and node.value.func.value.value.id == "os"
 and node.value.func.value.attr == "environ"
 and node.value.func.attr == "get"
 and len(node.value.args) in [1, 2]
-and isinstance(node.value.args[0], STR_TYPES)
+and isinstance(node.value.args[0], ast.Constant)
 )
 if isGetCall:
 call = node.value
 stringPart = call.args[0]
-if isinstance(stringPart, ast.Str):
+envName = stringPart.value
-envName = stringPart.s  # Python 3.6 / 3.7 fallback
-else:
-envName = stringPart.value
 # Check if this has a change
 hasChange = envName != envName.upper()
 if not (isIndexCall or isGetCall) or not hasChange:
 return
 if isIndexCall:
 isinstance(node.test, ast.Compare)
 and isinstance(node.test.left, ast.Name)
 and len(node.test.ops) == 1
 and isinstance(node.test.ops[0], ast.Eq)
 and len(node.test.comparators) == 1
-and isinstance(node.test.comparators[0], AST_CONST_TYPES)
+and isinstance(node.test.comparators[0], ast.Constant)
 and len(node.body) == 1
 and isinstance(node.body[0], ast.Return)
 and len(node.orelse) == 1
 and isinstance(node.orelse[0], ast.If)
 ):
 elseValue = None
 if node.body[0].value is not None:
 bodyValueStr = unparse(node.body[0].value).strip("'")
 else:
 bodyValueStr = "None"
-if isinstance(node.test.comparators[0], ast.Str):
+if AstUtilities.isString(node.test.comparators[0]):
 value = (
 bodyValueStr
 if bodyValueStr[0] == '"' and bodyValueStr[-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:
 keyValuePairs = {node.test.comparators[0].value: bodyValueStr}
 while child:
 if not (
 isinstance(child.test, ast.Compare)
 and isinstance(child.test.left, ast.Name)
 and child.test.left.id == variable.id
 and len(child.test.ops) == 1
 and isinstance(child.test.ops[0], ast.Eq)
 and len(child.test.comparators) == 1
-and isinstance(child.test.comparators[0], AST_CONST_TYPES)
+and isinstance(child.test.comparators[0], ast.Constant)
 and len(child.body) == 1
 and isinstance(child.body[0], ast.Return)
 and len(child.orelse) <= 1
 ):
 return
 returnCall = child.body[0]
 if isinstance(returnCall.value, ast.Call):
 return
-if isinstance(child.test.comparators[0], ast.Str):
+key = child.test.comparators[0].value
-key = child.test.comparators[0].s
-elif isinstance(child.test.comparators[0], ast.Num):
-key = child.test.comparators[0].n
-else:
-key = child.test.comparators[0].value
 value = unparse(child.body[0].value)
 if value[0] == '"' and value[-1] == '"':
 value = value[1:-1]
 keyValuePairs[key] = value
 @param node reference to the AST node to be checked
 @type ast.IfExp
 """
 # True if a else False
 if (
-isinstance(node.body, BOOL_CONST_TYPES)
+isinstance(node.body, ast.Constant)
 and node.body.value is True
-and isinstance(node.orelse, BOOL_CONST_TYPES)
+and isinstance(node.orelse, ast.Constant)
 and node.orelse.value is False
 ):
 cond = unparse(node.test)
 if isinstance(node.test, ast.Name):
 newCond = "bool({0})".format(cond)
 @param node reference to the AST node to be checked
 @type ast.IfExp
 """
 # False if a else True
 if (
-isinstance(node.body, BOOL_CONST_TYPES)
+isinstance(node.body, ast.Constant)
 and node.body.value is False
-and isinstance(node.orelse, BOOL_CONST_TYPES)
+and isinstance(node.orelse, ast.Constant)
 and node.orelse.value is True
 ):
 cond = unparse(node.test)
 if isinstance(node.test, ast.Name):
 newCond = "not {0}".format(cond)
 @type ast.BoolOp
 """
 # a or True
 if isinstance(node.op, ast.Or):
 for exp in node.values:
-if isinstance(exp, BOOL_CONST_TYPES) and exp.value is True:
+if isinstance(exp, ast.Constant) and exp.value is True:
 self.__error(node.lineno - 1, node.col_offset, "Y223")
 def __check224(self, node):
 """
 Private method to check for calls of the type "... and False".
 @type ast.BoolOp
 """
 # a and False
 if isinstance(node.op, ast.And):
 for exp in node.values:
-if isinstance(exp, BOOL_CONST_TYPES) and exp.value is False:
+if isinstance(exp, ast.Constant) and exp.value is False:
 self.__error(node.lineno - 1, node.col_offset, "Y224")
 def __check301(self, node):
 """
 Private method to check for Yoda conditions.
 @param node reference to the AST node to be checked
 @type ast.Compare
 """
 # 42 == age
 if (
-isinstance(node.left, AST_CONST_TYPES)
+isinstance(node.left, ast.Constant)
 and len(node.ops) == 1
 and isinstance(node.ops[0], ast.Eq)
 ):
 left = unparse(node.left)
-isPy37Str = isinstance(node.left, ast.Str)
+isStr = isinstance(node.left, ast.Constant) and isinstance(
-isPy38Str = isinstance(node.left, ast.Constant) and isinstance(
 node.left.value, str
 )
-if isPy37Str or isPy38Str:
+if isStr:
 left = f"'{left}'"
 right = unparse(node.comparators[0])
 self.__error(node.lineno - 1, node.col_offset, "Y301", left, right)
 def __check401(self, node):
 @type ast.Call
 """
 if (
 isinstance(node.func, ast.Attribute)
 and node.func.attr == "split"
-and isinstance(node.func.value, (ast.Str, ast.Constant))
+and isinstance(node.func.value, ast.Constant)
 ):
-if isinstance(node.func.value, ast.Constant):
+value = node.func.value.value
-value = node.func.value.value
-else:
-value = node.func.value.s
 expected = json.dumps(value.split())
 actual = unparse(node.func.value) + ".split()"
 self.__error(node.lineno - 1, node.col_offset, "Y905", expected, actual)
 and arg.func.attr == "join"
 ):
 names += getOsPathJoinArgs(arg)
 elif isinstance(arg, ast.Name):
 names.append(arg.id)
-elif isinstance(arg, ast.Str):
+elif AstUtilities.isString(arg):
-names.append(f"'{arg.s}'")
+names.append(f"'{arg.value}'")
 return names
 if (
 isinstance(node.func, ast.Attribute)
 and isinstance(node.func.value, ast.Attribute)
 return
 hasNone = False
 others = []
 for elt in tupleVar.elts:
-if isinstance(elt, BOOL_CONST_TYPES) and elt.value is None:
+if isinstance(elt, ast.Constant) and elt.value is None:
 hasNone = True
 else:
 others.append(elt)
 if len(others) == 1 and hasNone:
 return
 # check the argument value
 if not (
 len(node.args) == 2
-and isinstance(node.args[1], BOOL_CONST_TYPES)
+and isinstance(node.args[1], ast.Constant)
 and node.args[1].value is None
 ):
 return
 actual = unparse(node)

Mercurial Repositories > eric / file comparison

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

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