remove deprecated AST node types

Author: masonproffitt

qastle/linq_util.py

@@ -122,26 +122,26 @@ def visit_Call(self, node):
         if function_name == 'Where':
             if len(args) != 1:
                 raise SyntaxError('Where() call must have exactly one argument')
-            if isinstance(args[0], ast.Str):
-                args[0] = unwrap_ast(ast.parse(args[0].s))
+            if isinstance(args[0], ast.Constant) and isinstance(args[0].value, str):
+                args[0] = unwrap_ast(ast.parse(args[0].value))
             if not isinstance(args[0], ast.Lambda):
                 raise SyntaxError('Where() call argument must be a lambda')
             return Where(source=self.visit(source),
                          predicate=self.visit(args[0]))
         elif function_name == 'Select':
             if len(args) != 1:
                 raise SyntaxError('Select() call must have exactly one argument')
-            if isinstance(args[0], ast.Str):
-                args[0] = unwrap_ast(ast.parse(args[0].s))
+            if isinstance(args[0], ast.Constant) and isinstance(args[0].value, str):
+                args[0] = unwrap_ast(ast.parse(args[0].value))
             if not isinstance(args[0], ast.Lambda):
                 raise SyntaxError('Select() call argument must be a lambda')
             return Select(source=self.visit(source),
                           selector=self.visit(args[0]))
         elif function_name == 'SelectMany':
             if len(args) != 1:
                 raise SyntaxError('SelectMany() call must have exactly one argument')
-            if isinstance(args[0], ast.Str):
-                args[0] = unwrap_ast(ast.parse(args[0].s))
+            if isinstance(args[0], ast.Constant) and isinstance(args[0].value, str):
+                args[0] = unwrap_ast(ast.parse(args[0].value))
             if not isinstance(args[0], ast.Lambda):
                 raise SyntaxError('SelectMany() call argument must be a lambda')
             return SelectMany(source=self.visit(source),
@@ -166,8 +166,8 @@ def visit_Call(self, node):
             if len(args) != 2:
                 raise SyntaxError('Aggregate() call must have exactly two arguments; found'
                                   + str(len(args)))
-            if isinstance(args[1], ast.Str):
-                args[1] = unwrap_ast(ast.parse(args[1].s))
+            if isinstance(args[1], ast.Constant) and isinstance(args[1].value, str):
+                args[1] = unwrap_ast(ast.parse(args[1].value))
             if not isinstance(args[1], ast.Lambda):
                 raise SyntaxError('Second Aggregate() call argument must be a lambda')
             return Aggregate(source=self.visit(source),
@@ -192,17 +192,17 @@ def visit_Call(self, node):
         elif function_name == 'All':
             if len(args) != 1:
                 raise SyntaxError('All() call must have exactly one argument')
-            if isinstance(args[0], ast.Str):
-                args[0] = unwrap_ast(ast.parse(args[0].s))
+            if isinstance(args[0], ast.Constant) and isinstance(args[0].value, str):
+                args[0] = unwrap_ast(ast.parse(args[0].value))
             if not isinstance(args[0], ast.Lambda):
                 raise SyntaxError('All() call argument must be a lambda')
             return All(source=self.visit(source),
                        predicate=self.visit(args[0]))
         elif function_name == 'Any':
             if len(args) != 1:
                 raise SyntaxError('Any() call must have exactly one argument')
-            if isinstance(args[0], ast.Str):
-                args[0] = unwrap_ast(ast.parse(args[0].s))
+            if isinstance(args[0], ast.Constant) and isinstance(args[0].value, str):
+                args[0] = unwrap_ast(ast.parse(args[0].value))
             if not isinstance(args[0], ast.Lambda):
                 raise SyntaxError('Any() call argument must be a lambda')
             return Any(source=self.visit(source),
@@ -218,17 +218,17 @@ def visit_Call(self, node):
         elif function_name == 'OrderBy':
             if len(args) != 1:
                 raise SyntaxError('OrderBy() call must have exactly one argument')
-            if isinstance(args[0], ast.Str):
-                args[0] = unwrap_ast(ast.parse(args[0].s))
+            if isinstance(args[0], ast.Constant) and isinstance(args[0].value, str):
+                args[0] = unwrap_ast(ast.parse(args[0].value))
             if not isinstance(args[0], ast.Lambda):
                 raise SyntaxError('OrderBy() call argument must be a lambda')
             return OrderBy(source=self.visit(source),
                            key_selector=self.visit(args[0]))
         elif function_name == 'OrderByDescending':
             if len(args) != 1:
                 raise SyntaxError('OrderByDescending() call must have exactly one argument')
-            if isinstance(args[0], ast.Str):
-                args[0] = unwrap_ast(ast.parse(args[0].s))
+            if isinstance(args[0], ast.Constant) and isinstance(args[0].value, str):
+                args[0] = unwrap_ast(ast.parse(args[0].value))
             if not isinstance(args[0], ast.Lambda):
                 raise SyntaxError('OrderByDescending() call argument must be a lambda')
             return OrderByDescending(source=self.visit(source),

qastle/transform.py

@@ -64,15 +64,6 @@ def visit_Name(self, node):
     def visit_Constant(self, node):
         return repr(node.value)
 
-    def visit_Num(self, node):
-        return repr(node.n)
-
-    def visit_Str(self, node):
-        return repr(node.s)
-
-    def visit_NameConstant(self, node):
-        return repr(node.value)
-
     @staticmethod
     def make_composite_node_string(node_type, *fields):
         return '(' + node_type + ''.join([' ' + field for field in fields]) + ')'
@@ -113,11 +104,11 @@ def visit_IfExp(self, node):
 
     def visit_UnaryOp(self, node):
         if (hasattr(ast, 'Constant') and isinstance(node.operand, ast.Constant)
-           or isinstance(node.operand, ast.Num)):
+           or (isinstance(node.operand, ast.Constant) and isinstance(node.operand.value, (int, float, complex)))):
             if isinstance(node.op, ast.UAdd):
                 return self.visit(node.operand)
             elif isinstance(node.op, ast.USub):
-                return self.visit(ast.Num(n=-node.operand.n))
+                return self.visit(ast.Constant(value=-node.operand.value))
         return self.make_composite_node_string(op_strings[type(node.op)],
                                                self.visit(node.operand))
 
@@ -302,9 +293,9 @@ def composite(self, children):
         elif node_type == 'attr':
             if len(fields) != 2:
                 raise SyntaxError('Attribute node must have two fields; found ' + str(len(fields)))
-            if not isinstance(fields[1], ast.Str):
+            if not (isinstance(fields[1], ast.Constant) and isinstance(fields[1].value, str)):
                 raise SyntaxError('Attribute name must be a string; found ' + str(type(fields[1])))
-            return ast.Attribute(value=fields[0], attr=fields[1].s, ctx=ast.Load())
+            return ast.Attribute(value=fields[0], attr=fields[1].value, ctx=ast.Load())
 
         elif node_type == 'subscript':
             if len(fields) != 2: