def p_expression_set(p):
'''expression : LBRACE csv RBRACE
| LBRACE csv COMMA RBRACE
| LBRACE RBRACE
'''
if len(p) == 3:
p[0] = ast.Set((), ast.Store())
else:
p[0] = ast.Set(p[2], ast.Store())
def ast_repr(x):
"""Similar to repr(), but returns an AST instead of a String, which when
evaluated will return the given value."""
if type(x) in (int, float): return ast.Num(n=x)
elif type(x) in (str, unicode): return ast.Str(s=x)
elif type(x) is list: return ast.List(elts=map(ast_repr, x))
elif type(x) is dict:
return ast.Dict(keys=map(ast_repr, x.keys()),
values=map(ast_repr, x.values()))
elif type(x) is set:
return ast.Set(elts=map(ast_repr, x))
elif type(x) is Literal:
return x.body
elif x is None:
return ast.Name(id="None")
elif x is True:
return ast.Name(id="True")
elif x is False:
return ast.Name(id="False")
elif isinstance(x, ast.AST):
fields = [ast.keyword(a, ast_repr(b)) for a, b in ast.iter_fields(x)]
return ast.Call(func=ast.Name(id=x.__class__.__name__),
args=[],
keywords=fields,
starargs=None,
kwargs=None)
raise Exception("Don't know how to ast_repr this: ", x)
def value2pyliteral(val): # noqa: C901
"""
Transforms a python value into a literal in AST form.
"""
if val is None:
return ast.NameConstant(value=None)
elif val is ...:
return ast.Ellipsis()
elif val is True:
return ast.NameConstant(value=True)
elif val is False:
return ast.NameConstant(value=False)
elif isinstance(val, int):
return ast.Num(n=val)
elif isinstance(val, float):
return ast.Num(n=val)
elif isinstance(val, str):
return ast.Str(s=val)
elif isinstance(val, bytes):
return ast.Bytes(s=val)
elif isinstance(val, tuple):
return ast.Tuple(elts=[value2pyliteral(item) for item in val])
elif isinstance(val, list):
return ast.List(elts=[value2pyliteral(item) for item in val])
elif isinstance(val, dict):
return ast.Dict(
# .keys() and .values() have been documented to return things in the
# same order since Py2
keys=[value2pyliteral(item) for item in val.keys()],
values=[value2pyliteral(item) for item in val.values()],
)
elif isinstance(val, set):
return ast.Set(elts=[value2pyliteral(item) for item in val])
else:
raise ValueError(f"Can't translate {val!r} into a literal")
def size_container_folding(value):
"""
Convert value to ast expression if size is not too big.
Converter for sized container.
"""
if len(value) < MAX_LEN:
if isinstance(value, list):
return ast.List(map(to_ast, value), ast.Load())
elif isinstance(value, tuple):
return ast.Tuple(map(to_ast, value), ast.Load())
elif isinstance(value, set):
return ast.Set(map(to_ast, value))
elif isinstance(value, dict):
keys = map(to_ast, value.iterkeys())
values = map(to_ast, value.itervalues())
return ast.Dict(keys, values)
elif isinstance(value, numpy.ndarray):
return ast.Call(func=ast.Attribute(ast.Name('numpy', ast.Load()),
'array', ast.Load()),
args=[to_ast(value.tolist())],
keywords=[],
starargs=None,
kwargs=None)
else:
raise ConversionError()
else:
raise ToNotEval()
def ast_repr(x):
"""Similar to repr(), but returns an AST instead of a String, which when
evaluated will return the given value."""
tx = type(x)
if tx in (int, float):
return ast.Num(n=x)
elif tx is bytes:
return ast.Bytes(s=x)
elif isinstance(x, str):
return ast.Str(s=x)
elif tx is list:
return ast.List(elts=list(map(ast_repr, x)))
elif tx is dict:
return ast.Dict(keys=list(map(ast_repr, x.keys())),
values=list(map(ast_repr, x.values())))
elif tx is set:
return ast.Set(elts=list(map(ast_repr, x)))
elif tx is Literal:
return x.body
elif tx is Captured:
return compat.Call(ast.Name(id="Captured"),
[x.val, ast_repr(x.name)], [])
elif tx in (bool, type(None)):
return ast.NameConstant(value=x)
elif isinstance(x, ast.AST):
fields = [ast.keyword(a, ast_repr(b)) for a, b in ast.iter_fields(x)]
# This hard-codes an expectation that ast classes will be
# bound to the name `ast`. There must be a better way.
return compat.Call(
ast.Attribute(value=ast.Name(id='ast', ctx=ast.Load()),
attr=x.__class__.__name__,
ctx=ast.Load()), [], fields)
raise Exception("Don't know how to ast_repr this: ", x)
def test_empty_iterable_literals(self):
self.assertSrcRoundtrips('()')
self.assertSrcRoundtrips('[]')
self.assertSrcRoundtrips('{}')
# Python has no literal for empty sets, but code_gen should produce an
# expression that evaluates to one.
self.assertEqual(astorexpr(ast.Set([])), set())
def to_node(self):
if self.is_tuple != '':
elements = self.__create_elements()
return ast.Tuple(elts=elements, ctx=ast.Load)
elif self.is_list != '':
elements = self.__create_elements()
return ast.List(elts=elements, ctx=ast.Load)
elif self.is_dict != '':
if self.values is None:
return ast.Dict(keys=[], values=[])
elif self.__is_dict():
keys, values = self.__create_keys_values()
return ast.Dict(keys=keys, values=values)
else:
elements = self.__create_elements()
return ast.Set(elts=elements, ctx=ast.Load)
elif self.name is not None:
return self.name.to_node()
elif self.number is not None:
return self.number.to_node()
elif self.none is not None:
return self.none.to_node()
elif self.boolean is not None:
return self.boolean.to_node()
elif self.string is not None:
return self.string[0].to_node()
def _new_constant(node, value):
if isinstance(value, ast.AST):
# convenient shortcut: return the AST object unchanged
return value
# FIXME: test the config directly here?
if value is None:
new_node = ast.Constant(value=None)
elif isinstance(value, (bool, int, float, complex, str, bytes)):
new_node = ast.Constant(value=value)
elif isinstance(value, (tuple, frozenset)):
if not _is_constant(value):
raise TypeError("container items are not constant")
new_node = ast.Constant(value=value)
elif isinstance(value, list):
elts = [_new_constant(node, elt) for elt in value]
new_node = ast.List(elts=elts, ctx=ast.Load())
elif isinstance(value, dict):
keys = []
values = []
for key, value in value.items():
keys.append(_new_constant(node, key))
values.append(_new_constant(node, value))
new_node = ast.Dict(keys=keys, values=values, ctx=ast.Load())
elif isinstance(value, set):
elts = [_new_constant(node, elt) for elt in value]
new_node = ast.Set(elts=elts, ctx=ast.Load())
else:
raise TypeError("unknown type: %s" % type(value).__name__)
copy_lineno(node, new_node)
return new_node
def generate_set(max_depth=None):
from expression import generate_expression
length = random.randrange(MAX_LIST_LENGTH)
elts = [
generate_expression(max_depth=max_depth - 1) for _ in range(length)
]
return ast.Set(elts)
def _py2ast(v, ctx):
if isinstance(v, (int, long, float)):
return ast.Num(v)
elif isinstance(v, str):
return ast.Str(v)
elif isinstance(v, list):
return ast.List([BaseASTOptimizer._py2ast(x, ctx) for x in v], ctx)
elif isinstance(v, dict):
items = v.items()
keys = [BaseASTOptimizer._py2ast(k, ctx) for k, v in items]
vals = [BaseASTOptimizer._py2ast(v, ctx) for k, v in items]
return ast.Dict(keys, vals)
elif isinstance(v, tuple):
return ast.Tuple([BaseASTOptimizer._py2ast(x, ctx) for x in v],
ctx)
elif isinstance(v, set):
assert isinstance(ctx, ast.Load)
return ast.Set([BaseASTOptimizer._py2ast(x, ctx) for x in v])
elif v is None:
assert isinstance(ctx, ast.Load)
return ast.Name('None', ctx)
elif v is True:
assert isinstance(ctx, ast.Load)
return ast.Name('True', ctx)
elif v is False:
assert isinstance(ctx, ast.Load)
return ast.Name('False', ctx)
else:
assert False, ('_py2ast', v)
def visit_SetComp(self, node: ast.SetComp) -> ast.Name:
self.simplified = True
return simplify_list_comp(
node,
self.new_stmts,
ast.Set(elts=[], ),
'add',
)
def parse_set(tp: ast.Tuple) -> ast.Set:
elements = tp.elements
if len(elements) != 3:
raise ParseError(f'incorrect format of set!: {tp}')
pattern = parse_node(elements[1])
if not isinstance(pattern, ast.Name):
raise ParseError(f'set!: not an identifier in {tp}')
value = parse_node(elements[2])
return ast.Set(pattern, value)
def make_set(cursor_trail, tree):
"""Set(expr* elts)
"""
selected_node = core_logic.get_node_at_cursor(cursor_trail, tree)
expr = selected_node if isinstance(selected_node,
ast.expr) else make_expression()
return ast.Set(elts=[expr])
def compile_terminal(sexp: List, closure: Dict) -> ast.AST:
"""
Compiles primitive type variable (language built-in) to AST node.
`closure` contains name bindings for target function. Variables of
non-primitive (built-in) types (without corresponding AST node)
are given a unique random name, converted to ast.Name and stored
in closure for the target function.
"""
if type(sexp) is bool:
return ast.NameConstant(value=sexp), closure
elif type(sexp) in (int, float, complex):
return ast.Num(n=sexp), closure
elif type(sexp) is str:
return ast.Str(s=sexp), closure
elif type(sexp) is bytes:
return ast.Bytes(s=sexp), closure
elif type(sexp) is list:
elts = []
for e in sexp:
e, closure = compile_terminal(e, closure)
elts.append(e)
return ast.List(elts=elts, ctx=ast.Load()), closure
elif type(sexp) is tuple:
elts = []
for e in sexp:
e, closure = compile_terminal(e, closure)
elts.append(e)
return ast.Tuple(elts=elts, ctx=ast.Load()), closure
elif type(sexp) is dict:
keys, values = [], []
for k, v in sexp.items():
k, closure = compile_terminal(k, closure)
v, closure = compile_terminal(v, closure)
keys.append(k)
values.append(v)
return ast.Dict(keys=keys, values=values), closure
elif type(sexp) is set:
elts = []
for e in sexp:
e, closure = compile_terminal(e, closure)
elts.append(e)
return ast.Set(elts=elts), closure
else:
# Generate random name and store variable in closure.
name = '_%s' % uuid.uuid4().hex
closure[name] = sexp
return ast.Name(id=name, ctx=ast.Load()), closure
def _node_with_elts(node: ast.AST, new_elts: typ.List[ast.expr]) -> ast.expr:
if isinstance(node, ast.Call):
node.args = new_elts
return node
elif isinstance(node, ast.List):
return ast.List(elts=new_elts)
elif isinstance(node, ast.Set):
return ast.Set(elts=new_elts)
elif isinstance(node, ast.Tuple):
return ast.Tuple(elts=new_elts)
else:
raise TypeError(f"Unexpected node type {type(node)}")
def _parse_assign_statement(self, env):
""" <assign_statement>
Parses the <assign_statement> language structure.
assign_statement -> '@' unary_expression '=' logical_expression ';'
"""
self._match('@')
unary = self._parse_unary_expression(env)
self._match('=')
logical = self._parse_logical_expression(env)
self._match(';')
return ast.Set(unary, logical)
def test__get_literal_value(self):
new_context = context.Context()
value = ast.Num(42)
expected = value.n
self.assertEqual(expected, new_context._get_literal_value(value))
value = ast.Str('spam')
expected = value.s
self.assertEqual(expected, new_context._get_literal_value(value))
value = ast.List([ast.Str('spam'), ast.Num(42)], ast.Load())
expected = [ast.Str('spam').s, ast.Num(42).n]
self.assertListEqual(expected, new_context._get_literal_value(value))
value = ast.Tuple([ast.Str('spam'), ast.Num(42)], ast.Load())
expected = (ast.Str('spam').s, ast.Num(42).n)
self.assertTupleEqual(expected, new_context._get_literal_value(value))
value = ast.Set([ast.Str('spam'), ast.Num(42)])
expected = set([ast.Str('spam').s, ast.Num(42).n])
self.assertSetEqual(expected, new_context._get_literal_value(value))
value = ast.Dict(['spam', 'eggs'], [42, 'foo'])
expected = dict(spam=42, eggs='foo')
self.assertDictEqual(expected, new_context._get_literal_value(value))
value = ast.Ellipsis()
self.assertIsNone(new_context._get_literal_value(value))
value = ast.Name('spam', ast.Load())
expected = value.id
self.assertEqual(expected, new_context._get_literal_value(value))
if six.PY3:
value = ast.NameConstant(True)
expected = str(value.value)
self.assertEqual(expected, new_context._get_literal_value(value))
if six.PY3:
value = ast.Bytes(b'spam')
expected = value.s
self.assertEqual(expected, new_context._get_literal_value(value))
self.assertIsNone(new_context._get_literal_value(None))
def to_node(value):
if isinstance(value, str):
return ast.Str(s=value)
elif isinstance(value, (int, float)):
return ast.Num(n=value)
elif isinstance(value, list):
return ast.List(elts=list(map(to_node, value)), ctx=ast.Load())
elif isinstance(value, tuple):
return ast.Tuple(elts=list(map(to_node, value)), ctx=ast.Load())
elif isinstance(value, dict):
keys = list(map(to_node, value.keys()))
values = list(map(to_node, value.values()))
return ast.Dict(keys=keys, values=values)
elif isinstance(value, set):
return ast.Set(elts=list(map(to_node, value)))
assert value is None or isinstance(value, ast.AST), \
'value must be None or AST instance, got {}'.format(
type(value).__name__
)
return value
def to_ast(self, value):
if (type(value) in (int, long, float, complex)):
return ast.Num(value)
elif isinstance(value, bool):
return ast.Attribute(ast.Name('__builtin__', ast.Load()),
'True' if value else 'False', ast.Load())
elif isinstance(value, str):
return ast.Str(value)
elif isinstance(value, list) and len(value) < ConstantFolding.MAX_LEN:
#SG: unsure whether it Load or something else
return ast.List(map(self.to_ast, value), ast.Load())
elif isinstance(value, tuple) and len(value) < ConstantFolding.MAX_LEN:
return ast.Tuple(map(self.to_ast, value), ast.Load())
elif isinstance(value, set) and len(value) < ConstantFolding.MAX_LEN:
return ast.Set(map(self.to_ast, value))
elif isinstance(value, dict) and len(value) < ConstantFolding.MAX_LEN:
keys = map(self.to_ast, value.iterkeys())
values = map(self.to_ast, value.itervalues())
return ast.Dict(keys, values)
else:
raise ConstantFolding.ConversionError()
def test__get_literal_value(self):
new_context = context.Context()
value = ast.Num(42)
expected = value.n
self.assertEqual(expected, new_context._get_literal_value(value))
value = ast.Str("spam")
expected = value.s
self.assertEqual(expected, new_context._get_literal_value(value))
value = ast.List([ast.Str("spam"), ast.Num(42)], ast.Load())
expected = [ast.Str("spam").s, ast.Num(42).n]
self.assertListEqual(expected, new_context._get_literal_value(value))
value = ast.Tuple([ast.Str("spam"), ast.Num(42)], ast.Load())
expected = (ast.Str("spam").s, ast.Num(42).n)
self.assertTupleEqual(expected, new_context._get_literal_value(value))
value = ast.Set([ast.Str("spam"), ast.Num(42)])
expected = {ast.Str("spam").s, ast.Num(42).n}
self.assertSetEqual(expected, new_context._get_literal_value(value))
value = ast.Dict(["spam", "eggs"], [42, "foo"])
expected = dict(spam=42, eggs="foo")
self.assertDictEqual(expected, new_context._get_literal_value(value))
value = ast.Ellipsis()
self.assertIsNone(new_context._get_literal_value(value))
value = ast.Name("spam", ast.Load())
expected = value.id
self.assertEqual(expected, new_context._get_literal_value(value))
value = ast.Bytes(b"spam")
expected = value.s
self.assertEqual(expected, new_context._get_literal_value(value))
self.assertIsNone(new_context._get_literal_value(None))
def visit_Compare(self, node):
# TODO: Implement or/and.
if len(node.ops) > 1:
return node
if isinstance(node.ops[0], ast.In):
return ast.BinOp(left=node.left,
op=ast.LShift(),
right=node.comparators[0])
if isinstance(node.ops[0], ast.Eq):
return ast.BinOp(left=node.left,
op=ast.LShift(),
right=ast.Set(node.comparators))
if isinstance(node.ops[0], ast.NotIn):
node_copy = copy.deepcopy(node)
node_copy.ops[0] = ast.In()
return ast.UnaryOp(op=ast.Invert(),
operand=self.visit_Compare(node_copy))
if isinstance(node.ops[0], ast.NotEq):
node_copy = copy.deepcopy(node)
node_copy.ops[0] = ast.Eq()
return ast.UnaryOp(op=ast.Invert(),
operand=self.visit_Compare(node_copy))
return node
def new_constant(value, node=None):
if isinstance(value, bool):
new_node = ast.Name(id='True' if value else 'False', ctx=ast.Load())
elif isinstance(value, (int, float, long, complex)):
new_node = ast.Num(n=value)
elif isinstance(value, (unicode, str)):
new_node = ast.Str(s=value)
elif isinstance(value, (tuple, list)):
cls = ast.Tuple if isinstance(value, tuple) else ast.List
elts = [new_constant(elt, node) for elt in value]
new_node = cls(elts=elts, ctx=ast.Load)
elif isinstance(value, set):
elts = [new_constant(elt, node) for elt in value]
new_node = ast.Set(elts=elts)
elif isinstance(value, dict):
keys = [new_constant(k, node) for k in value.keys()]
values = [new_constant(v, node) for v in value.values()]
new_node = ast.Dict(keys=keys, values=values)
elif isinstance(value, frozenset):
elts = [new_constant(elt, node) for elt in value]
arg = ast.Tuple(elts=elts, ctx=ast.Load())
func = ast.Name(id='frozenset', ctx=ast.Load())
new_node = ast.Call(func=func,
args=[arg],
keywords=[],
starargs=None,
kwargs=None)
elif value is None:
new_node = ast.Name(id='None', ctx=ast.Load())
else:
raise TypeError("unknown type: %s" % type(value).__name__)
node and copy_lineno(node, new_node)
new_node.__preinit__(parent=node.parent if node else node.parent)
new_node.__postinit__()
return new_node
def visit_set_statement(self, stmt: coll_stmt.SetStatement) -> None:
# There is no literal for empty sets, so we have to write "set()"
inner: Any
if len(stmt.elements) == 0:
inner = ast.Call(func=ast.Name(id="set", ctx=ast.Load()),
args=[],
keywords=[])
else:
inner = ast.Set(
elts=[
au.create_var_name(self._variable_names, x, True)
for x in stmt.elements
],
ctx=ast.Load(),
)
self._ast_nodes.append(
ast.Assign(
targets=[
au.create_var_name(self._variable_names, stmt.ret_val,
False)
],
value=inner,
))
def as_ast(dct):
"""See https://docs.python.org/2/library/ast.html"""
if dct['ast_type'] == "Module":
return ast.Module(dct["body"])
elif dct['ast_type'] == "Interactive":
return ast.Interactive(dct["body"])
elif dct['ast_type'] == "Expression":
return ast.Expression(dct["body"])
elif dct['ast_type'] == "Suite":
return ast.Suite(dct["body"])
elif dct['ast_type'] == "FunctionDef":
return ast.FunctionDef(dct["name"], dct["args"], dct["body"],
dct["decorator_list"])
elif dct['ast_type'] == "ClassDef":
return ast.ClassDef(dct["name"], dct["bases"], dct["body"],
dct["decorator_list"])
elif dct['ast_type'] == "Return":
return ast.Return(dct["value"])
elif dct['ast_type'] == "Delete":
return ast.Delete(dct["targets"])
elif dct['ast_type'] == "Assign":
return ast.Assign(dct["targets"], dct["value"])
elif dct['ast_type'] == "AugAssign":
return ast.AugAssign(dct["target"], dct["op"], dct["value"])
elif dct['ast_type'] == "Print":
return ast.Print(dct["dest"], dct["values"], dct["nl"])
elif dct['ast_type'] == "For":
return ast.For(dct["target"], dct["iter"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "While":
return ast.While(dct["test"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "If":
return ast.If(dct["test"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "With":
return ast.With(dct["context_expr"], dct["optional_vars"], dct["body"])
elif dct['ast_type'] == "Raise":
return ast.Raise(dct["type"], dct["inst"], dct["tback"])
elif dct['ast_type'] == "TryExcept":
return ast.TryExcept(dct["body"], dct["handlers"], dct["orelse"])
elif dct['ast_type'] == "TryFinally":
return ast.TryFinally(dct["body"], dct["finalbody"])
elif dct['ast_type'] == "Assert":
return ast.Assert(dct["test"], dct["msg"])
elif dct['ast_type'] == "Import":
return ast.Import(dct["names"])
elif dct['ast_type'] == "ImportFrom":
return ast.ImportFrom(dct["module"], dct["names"], dct["level"])
elif dct['ast_type'] == "Exec":
return ast.Exec(dct["body"], dct["globals"], dct["locals"])
elif dct['ast_type'] == "Global":
return ast.Global(dct["names"])
elif dct['ast_type'] == "Expr":
return ast.Expr(dct["value"])
elif dct['ast_type'] == "Pass":
return ast.Pass()
elif dct['ast_type'] == "Break":
return ast.Break()
elif dct['ast_type'] == "Continue":
return ast.Continue()
elif dct['ast_type'] == "BoolOp":
return ast.BoolOp(dct["op"], dct["values"])
elif dct['ast_type'] == "BinOp":
return ast.BinOp(dct["left"], dct["op"], dct["right"])
elif dct['ast_type'] == "UnaryOp":
return ast.UnaryOp(dct["op"], dct["operand"])
elif dct['ast_type'] == "Lambda":
return ast.Lambda(dct["args"], dct["body"])
elif dct['ast_type'] == "IfExp":
return ast.IfExp(dct["test"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "Dict":
return ast.Dict(dct["keys"], dct["values"])
elif dct['ast_type'] == "Set":
return ast.Set(dct["elts"])
elif dct['ast_type'] == "ListComp":
return ast.ListComp(dct["elt"], dct["generators"])
elif dct['ast_type'] == "SetComp":
return ast.SetComp(dct["elt"], dct["generators"])
elif dct['ast_type'] == "DictComp":
return ast.DictComp(dct["key"], dct["value"], dct["generators"])
elif dct['ast_type'] == "GeneratorExp":
return ast.GeneratorExp(dct["elt"], dct["generators"])
elif dct['ast_type'] == "Yield":
return ast.Yield(dct["value"])
elif dct['ast_type'] == "Compare":
return ast.Compare(dct["left"], dct["ops"], dct["comparators"])
elif dct['ast_type'] == "Call":
return ast.Call(dct["func"], dct["args"], dct["keywords"],
dct["starargs"], dct["kwargs"])
elif dct['ast_type'] == "Repr":
return ast.Repr(dct["value"])
elif dct['ast_type'] == "Num":
return ast.Num(dct["n"])
elif dct['ast_type'] == "Str":
# Converting to ASCII
return ast.Str(dct["s"].encode('ascii', 'ignore'))
elif dct['ast_type'] == "Attribute":
return ast.Attribute(dct["value"], dct["attr"], dct["ctx"])
elif dct['ast_type'] == "Subscript":
return ast.Subscript(dct["value"], dct["slice"], dct["ctx"])
elif dct['ast_type'] == "Name":
return ast.Name(dct["id"], dct["ctx"])
elif dct['ast_type'] == "List":
return ast.List(dct["elts"], dct["ctx"])
elif dct['ast_type'] == "Tuple":
return ast.Tuple(dct["elts"], dct["ctx"])
elif dct['ast_type'] == "Load":
return ast.Load()
elif dct['ast_type'] == "Store":
return ast.Store()
elif dct['ast_type'] == "Del":
return ast.Del()
elif dct['ast_type'] == "AugLoad":
return ast.AugLoad()
elif dct['ast_type'] == "AugStore":
return ast.AugStore()
elif dct['ast_type'] == "Param":
return ast.Param()
elif dct['ast_type'] == "Ellipsis":
return ast.Ellipsis()
elif dct['ast_type'] == "Slice":
return ast.Slice(dct["lower"], dct["upper"], dct["step"])
elif dct['ast_type'] == "ExtSlice":
return ast.ExtSlice(dct["dims"])
elif dct['ast_type'] == "Index":
return ast.Index(dct["value"])
elif dct['ast_type'] == "And":
return ast.And()
elif dct['ast_type'] == "Or":
return ast.Or()
elif dct['ast_type'] == "Add":
return ast.Add()
elif dct['ast_type'] == "Sub":
return ast.Sub()
elif dct['ast_type'] == "Mult":
return ast.Mult()
elif dct['ast_type'] == "Div":
return ast.Div()
elif dct['ast_type'] == "Mod":
return ast.Mod()
elif dct['ast_type'] == "Pow":
return ast.Pow()
elif dct['ast_type'] == "LShift":
return ast.LShift()
elif dct['ast_type'] == "RShift":
return ast.RShift()
elif dct['ast_type'] == "BitOr":
return ast.BitOr()
elif dct['ast_type'] == "BitXor":
return ast.BitXor()
elif dct['ast_type'] == "BitAnd":
return ast.BitAnd()
elif dct['ast_type'] == "FloorDiv":
return ast.FloorDiv()
elif dct['ast_type'] == "Invert":
return ast.Invert()
elif dct['ast_type'] == "Not":
return ast.Not()
elif dct['ast_type'] == "UAdd":
return ast.UAdd()
elif dct['ast_type'] == "USub":
return ast.USub()
elif dct['ast_type'] == "Eq":
return ast.Eq()
elif dct['ast_type'] == "NotEq":
return ast.NotEq()
elif dct['ast_type'] == "Lt":
return ast.Lt()
elif dct['ast_type'] == "LtE":
return ast.LtE()
elif dct['ast_type'] == "Gt":
return ast.Gt()
elif dct['ast_type'] == "GtE":
return ast.GtE()
elif dct['ast_type'] == "Is":
return ast.Is()
elif dct['ast_type'] == "IsNot":
return ast.IsNot()
elif dct['ast_type'] == "In":
return ast.In()
elif dct['ast_type'] == "NotIn":
return ast.NotIn()
elif dct['ast_type'] == "comprehension":
return ast.comprehension(dct["target"], dct["iter"], dct["ifs"])
elif dct['ast_type'] == "ExceptHandler":
return ast.ExceptHandler(dct["type"], dct["name"], dct["body"])
elif dct['ast_type'] == "arguments":
return ast.arguments(dct["args"], dct["vararg"], dct["kwarg"],
dct["defaults"])
elif dct['ast_type'] == "keyword":
return ast.keyword(dct["arg"], dct["value"])
elif dct['ast_type'] == "alias":
return ast.alias(dct["name"], dct["asname"])
else:
return dct
def test_empty_set(self):
self.assertASTEqual(ast.parse(ast.unparse(ast.Set(elts=[]))),
ast.parse('{*()}'))
def test_invalid_set(self):
self.check_invalid(ast.Set(elts=[]))
def test_Set(self):
self.verify(ast.Set([ast.Num(42)]), '{42}')
self.verify(ast.Set([ast.Num(2), ast.Num(3)]), '{2,3}')
def test_set(self):
self.expr(ast.Set([None]), "None disallowed")
s = ast.Set([ast.Name("x", ast.Store())])
self.expr(s, "must have Load context")
def visit_Str(self, node):
return ast.Set(words_dict[node.s])
def mk_set(elements):
return ast.Set(elts=list(elements))
