def test_dictcomp(self):
g = ast.comprehension(ast.Name("y", ast.Store()),
ast.Name("p", ast.Load()), [], 0)
c = ast.DictComp(ast.Name("x", ast.Store()),
ast.Name("y", ast.Load()), [g])
self.expr(c, "must have Load context")
c = ast.DictComp(ast.Name("x", ast.Load()),
ast.Name("y", ast.Store()), [g])
self.expr(c, "must have Load context")
def factory(comps):
k = ast.Name("x", ast.Load())
v = ast.Name("y", ast.Load())
return ast.DictComp(k, v, comps)
self._check_comprehension(factory)
def DictComp(draw, expression) -> ast.DictComp:
return ast.DictComp(key=draw(expression),
value=draw(expression),
generators=draw(
lists(comprehension(expression),
min_size=1,
max_size=3)))
def visitDictComp(self, n, varchecks, *args):
generators, varchecks = self.handleComprehensions(
n.generators, n.lineno, n.col_offset, varchecks, *args)
key = self.dispatch(n.key, varchecks, *args)
value = self.dispatch(n.value, varchecks, *args)
return ast.DictComp(key=key, value=value, generators=generators)
def test_DictComp(self):
gen = ast.comprehension(ast.Name('x', ast.Store()),
ast.Name('y', ast.Load()), [ast.Num(2)])
dictcomp = ast.DictComp(ast.Name('v', ast.Load()),
ast.Name('w', ast.Load()), [gen])
self.verify(dictcomp, '{v:w for x in y if 2}')
gen2 = ast.comprehension(ast.Name('a', ast.Store()),
ast.Name('b', ast.Load()), [])
dictcomp.generators.append(gen2)
self.verify(dictcomp, '{v:w for x in y if 2 for a in b}')
def visit_DictComp(self, node: DictComp, *args, **kwargs) -> C.DictComp:
key = self.visit(node.key, *args, **kwargs)
value = self.visit(node.value, *args, **kwargs)
generators = self.visit(node.generators, *args, **kwargs)
return C.DictComp(
key=key,
value=value,
generators=generators,
)
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 factory(comps):
k = ast.Name("x", ast.Load())
v = ast.Name("y", ast.Load())
return ast.DictComp(k, v, comps)
def test_operators(self):
boolop0 = ast.BoolOp()
boolop1 = ast.BoolOp(ast.And(),
[ ast.Name('True', ast.Load()), ast.Name('False', ast.Load()), ast.Name('a',ast.Load())])
boolop2 = ast.BoolOp(ast.And(),
[ ast.Name('True', ast.Load()), ast.Name('False', ast.Load()), ast.Name('a',ast.Load())],
0, 0)
binop0 = ast.BinOp()
binop1 = ast.BinOp(ast.Str('xy'), ast.Mult(), ast.Num(3))
binop2 = ast.BinOp(ast.Str('xy'), ast.Mult(), ast.Num(3), 0, 0)
unaryop0 = ast.UnaryOp()
unaryop1 = ast.UnaryOp(ast.Not(), ast.Name('True',ast.Load()))
unaryop2 = ast.UnaryOp(ast.Not(), ast.Name('True',ast.Load()), 0, 0)
lambda0 = ast.Lambda()
lambda1 = ast.Lambda(ast.arguments([ast.Name('x', ast.Param())], None, None, []), ast.Name('x', ast.Load()))
ifexp0 = ast.IfExp()
ifexp1 = ast.IfExp(ast.Name('True',ast.Load()), ast.Num(1), ast.Num(0))
ifexp2 = ast.IfExp(ast.Name('True',ast.Load()), ast.Num(1), ast.Num(0), 0, 0)
dict0 = ast.Dict()
dict1 = ast.Dict([ast.Num(1), ast.Num(2)], [ast.Str('a'), ast.Str('b')])
dict2 = ast.Dict([ast.Num(1), ast.Num(2)], [ast.Str('a'), ast.Str('b')], 0, 0)
set0 = ast.Set()
set1 = ast.Set([ast.Num(1), ast.Num(2)])
set2 = ast.Set([ast.Num(1), ast.Num(2)], 0, 0)
lc0 = ast.ListComp()
lc1 = ast.ListComp( ast.Name('x',ast.Load()),
[ast.comprehension(ast.Name('x', ast.Store()),
ast.Tuple([ast.Num(1), ast.Num(2)], ast.Load()), [])])
lc2 = ast.ListComp( ast.Name('x',ast.Load()),
[ast.comprehension(ast.Name('x', ast.Store()),
ast.Tuple([ast.Num(1), ast.Num(2)], ast.Load()), [])], 0, 0)
setcomp0 = ast.SetComp()
setcomp1 = ast.SetComp(ast.Name('x', ast.Load()),
[ast.comprehension(ast.Name('x', ast.Store()), ast.Str('abracadabra'),
[ast.Compare(ast.Name('x', ast.Load()), [ast.NotIn()],
[ast.Str('abc')])])])
comprehension0 = ast.comprehension()
comprehension1 = ast.comprehension(ast.Name('x', ast.Store()),
ast.Tuple([ast.Num(1), ast.Num(2)], ast.Load()), [])
# "{i : chr(65+i) for i in (1,2)}")
dictcomp0 = ast.DictComp()
dictcomp1 = ast.DictComp(ast.Name('i', ast.Load()),
ast.Call(ast.Name('chr', ast.Load()),
[ast.BinOp(ast.Num(65), ast.Add(), ast.Name('i', ast.Load()))],
[], None, None),
[ast.comprehension(ast.Name('i', ast.Store()),
ast.Tuple([ast.Num(1), ast.Num(n=2)], ast.Load()), [])])
dictcomp2 = ast.DictComp(ast.Name('i', ast.Load()),
ast.Call(ast.Name('chr', ast.Load()),
[ast.BinOp(ast.Num(65), ast.Add(), ast.Name('i', ast.Load()))],
[], None, None),
[ast.comprehension(ast.Name('i', ast.Store()),
ast.Tuple([ast.Num(1), ast.Num(n=2)], ast.Load()), [])],0,0)
# (x for x in (1,2))
genexp0 = ast.GeneratorExp()
genexp1 = ast.GeneratorExp(ast.Name('x', ast.Load()),
[ast.comprehension(ast.Name('x', ast.Store()),
ast.Tuple([ast.Num(1), ast.Num(2)], ast.Load()), [])])
genexp2 = ast.GeneratorExp(ast.Name('x', ast.Load()),
[ast.comprehension(ast.Name('x', ast.Store()),
ast.Tuple([ast.Num(1), ast.Num(2)], ast.Load()), [])],0,0)
# yield 2
yield0 = ast.Yield()
yield1 = ast.Yield(ast.Num(2))
yield2 = ast.Yield(ast.Num(2),0,0)
yield20 = ast.Yield(lineno=0, col_offset=0)
# a>0
compare0 = ast.Compare()
compare1 = ast.Compare(ast.Name('a', ast.Load()), [ast.Gt()], [ast.Num(0)])
compare2 = ast.Compare(ast.Name('a', ast.Load()), [ast.Gt()], [ast.Num(0)],0,0)
# chr(65)
call0 = ast.Call()
call1 = ast.Call(ast.Name('chr', ast.Load()), [ast.Num(65)], [], None, None)
call2 = ast.Call(ast.Name('chr', ast.Load()), [ast.Num(65)], [], None, None, 0, 0)
call20 = ast.Call(ast.Name('f', ast.Load()), [ast.Num(0)], [])
call21 = ast.Call(ast.Name('f', ast.Load()), [ast.Num(0)], [], lineno=0, col_offset=0)
# 0
num0 = ast.Num()
num1 = ast.Num(0)
num2 = ast.Num(0,0,0)
# "foo"
str0 = ast.Str()
str1 = ast.Str("foo")
str2 = ast.Str("foo",0,0)
# TODO: come back
repr0 = ast.Repr()
repr1 = ast.Repr(ast.Num(0))
repr2 = ast.Repr(ast.Num(0),0,0)
# foo.bar
attr0 = ast.Attribute()
attr1 = ast.Attribute(ast.Name('foo', ast.Load()), 'bar', ast.Load())
attr2 = ast.Attribute(ast.Name('foo', ast.Load()), 'bar', ast.Load(), 0,0)
# a[1:2]
subscript0 = ast.Subscript()
subscript1 = ast.Subscript(ast.Name('a', ast.Load()), ast.Slice(ast.Num(1), ast.Num(2)), ast.Load())
subscript2 = ast.Subscript(ast.Name('a', ast.Load()), ast.ExtSlice([ast.Num(1), ast.Num(2)]), ast.Load(), 0, 0)
# name
name0 = ast.Name()
name1 = ast.Name("name", ast.Load())
name2 = ast.Name("name", ast.Load(),0,0)
# [1,2]
list0 = ast.List()
list1 = ast.List([ast.Num(1), ast.Num(2)], ast.Load())
list2 = ast.List([ast.Num(1), ast.Num(2)], ast.Load(),0,0)
# (1,2)
tuple0 = ast.Tuple()
tuple1 = ast.Tuple([ast.Num(1), ast.Num(2)], ast.Load())
tuple2 = ast.Tuple([ast.Num(1), ast.Num(2)], ast.Load(), 0, 0)
def visitDictComp(self, n, *args):
generators = self.reduce(n.generators, *args)
key = self.dispatch(n.key, *args)
value = self.dispatch(n.value, *args)
return ast.DictComp(key=key, value=value, generators=generators)
def generate(self, element:Element, GC:GenerationContext):
acode = element.code
head = acode[0].code
assert isinstance(head, Identifier)
headtext = head.full_name
if len(acode) is 2 and is_form(acode[1].code, "for"):
ccode = acode[1].code
assert len(ccode) == 3
target_iter_element = ccode[1]
expr_element = ccode[2]
with GC.let(domain=LVDom):
target_code = GC.generate(target_iter_element.code[1])
with GC.let(domain=ExDom):
iter_code = GC.generate(target_iter_element.code[2])
comp_code = ast.comprehension(target=target_code,
iter=iter_code,
ifs=[])
if is_form(expr_element.code, "="):
# dict comp
key_code = GC.generate(expr_element.code[1])
value_code = GC.generate(expr_element.code[2])
return ast.DictComp(key=key_code, value=value_code,
generators=[comp_code])
else:
# set comp
elt_code = GC.generate(expr_element)
return ast.SetComp(elt=elt_code, generators=[comp_code])
else:
if len(acode) is 1:
return ast.Dict([], [])
if all([is_form(i.code, "=") for i in acode[1:]]):
#dict
keys = []
values = []
with GC.let(domain=ExDom):
for kvpair_el in acode[1:]:
kvpair = kvpair_el.code
key_code = GC.generate(kvpair[1])
value_code = GC.generate(kvpair[2])
keys.append(key_code)
values.append(value_code)
return expr_wrap(ast.Dict(keys, values), GC)
else:
#set
el_codes = self.generate_as_expressions(GC, *acode[1:])
return expr_wrap(ast.Set(el_codes), GC)
def dictorsetmaker(self, p):
return ast.DictComp(key=p.test0, value=p.test1, generators=p.comp_for)
