def test_num():
tree = eparse(1)
assert tree.emit() == '1'
tree2 = from_ast(tree.to_ast(), mode='eval')
assert tree2.emit() == '1'
tree3 = mparse(1)
assert tree3.emit() == '1'
tree4 = from_ast(tree3.to_ast(), mode='exec')
assert tree4.emit() == '1'
tree5 = iparse(1)
assert tree5.emit() == '1'
tree6 = from_ast(tree5.to_ast(), mode='single')
assert tree6.emit() == '1'
tree7 = tree3.abstract()
assert any(n.lineno is not None for n in tree3.nodes)
assert all(n.lineno is None for n in tree7.nodes)
from syn.python.b import Num as Num_
import syn.python.b.base as pybbase
def bad():
class Num(PythonNode):
pass
assert_raises(TypeError, bad)
assert pybbase.AST_REGISTRY[ast.Num] is Num_
n = Num(1)
assert n.emit() == '1'
assert n.emit(indent_level=1) == ' 1'
assert n.as_value().emit() == '1'
rn = n.as_return()
assert rn.emit() == 'return 1'
assert n.emit() == '1'
def test_num():
tree = eparse(1)
assert tree.emit() == '1'
tree2 = from_ast(tree.to_ast(), mode='eval')
assert tree2.emit() == '1'
tree3 = mparse(1)
assert tree3.emit() == '1'
tree4 = from_ast(tree3.to_ast(), mode='exec')
assert tree4.emit() == '1'
tree5 = iparse(1)
assert tree5.emit() == '1'
tree6 = from_ast(tree5.to_ast(), mode='single')
assert tree6.emit() == '1'
tree7 = tree3.abstract()
assert any(n.lineno is not None for n in tree3.nodes)
assert all(n.lineno is None for n in tree7.nodes)
from syn.python.b import Num as Num_
import syn.python.b.base as pybbase
def bad():
class Num(PythonNode):
pass
assert_raises(TypeError, bad)
assert pybbase.AST_REGISTRY[ast.Num] is Num_
n = Num(1)
assert n.emit() == '1'
assert n.emit(indent_level=1) == ' 1'
assert n.as_value().emit() == '1'
rn = n.as_return()
assert rn.emit() == 'return 1'
assert n.emit() == '1'
def test_call():
examine('foo()')
examine('foo(1)')
examine('foo(1, 2, 3)')
examine('foo(a=1, b=2)')
examine('foo(1, 2, **d)')
if VER < '3.5':
examine('foo(a=2, *c)')
else:
examine('foo(*c, a=2)')
examine('foo(*c)')
examine('foo(**d)')
examine('foo(1, a=2, **b)')
if VER < '3.5':
examine('foo(1, 2, a=3, b=4, *c, **d)')
else:
examine('foo(1, 2, *c, a=3, b=4, **d)')
assert Call(Name('list')).emit() == 'list()'
c1 = Call(Name('c1'),
[Num(2),
Assign([Name('x')],
Num(3)),
Assign([Name('y')],
Num(4))])
assert c1.emit() == 'c1(2, x = 3, y = 4)'
assert_raises(TypeError, c1.validate)
c1r = Module(c1).expressify_statements().resolve_progn()
c1r.emit()
assert c1r.emit() == 'x = 3\ny = 4\nc1(2, x, y)'
k = Keyword('foo', Num(1))
assert k.emit() == 'foo=1'
if VER >= '3.5':
k = Keyword(None, Name('x'))
assert k.emit() == '**x'
if VER < '3.5':
c = Call(Name('foo'),
[Num(1), Num(2)],
[Keyword('a', Num(3)), Keyword('b', Num(4))],
Name('c'),
Name('d'))
assert c.emit() == 'foo(1, 2, a=3, b=4, *c, **d)'
assert c.emit(indent_level=1) == ' foo(1, 2, a=3, b=4, *c, **d)'
else:
c = Call(Name('foo'),
[Num(1), Num(2), Starred(Name('c'))],
[Keyword('a', Num(3)),
Keyword('b', Num(4)),
Keyword(None, Name('d'))])
assert c.emit() == 'foo(1, 2, *c, a=3, b=4, **d)'
assert c.emit(indent_level=1) == ' foo(1, 2, *c, a=3, b=4, **d)'
c = Call(Name('foo'))
assert c.emit() == 'foo()'
def test_sequence():
examine('[1, 2]')
examine('(1, 2)')
examine('(1,)')
examine('{1}')
l = List([Num(1), Num(2)])
assert l.emit() == '[1, 2]'
assert l.emit(indent_level=1) == ' [1, 2]'
t = Tuple([Num(1), Num(2)])
assert t.emit() == '(1, 2)'
assert t.emit(indent_level=1) == ' (1, 2)'
s = Set([Num(1), Num(2)])
assert s.emit() == '{1, 2}'
assert s.emit(indent_level=1) == ' {1, 2}'
assert s._node_count == 3
assert s._children == s.elts
k = getkey(s._child_map, ('elts', 1))
s._set_child(k, Tuple([Num(3), Num(4)]))
assert s.emit() == '{1, (3, 4)}'
assert s._children == [Num(1), Tuple([Num(3), Num(4)], ctx=Load())]
assert s._node_count == 6
def test_if():
examine('if 1:\n a = 1')
examine('if 1:\n a = 1\nelse:\n a = 2')
examine(
'if 1:\n a = 1\nelif 2:\n a = 2\nelse:\n a = 3',
'if 1:\n a = 1\nelse:\n if 2:\n a = 2\n else:\n a = 3'
)
if1 = If(Num(1), [Num(2)], [Num(3)])
assert if1.emit() == 'if 1:\n 2\nelse:\n 3'
rif1 = if1.as_return()
assert rif1.emit() == 'if 1:\n return 2\nelse:\n return 3'
if2 = If(Assign([Name('x')], Num(2)), [Return(Num(5))])
assert if2.emit() == 'if x = 2:\n return 5'
assert_raises(TypeError, if2.validate) # Indeed, this isn't valid python
if2r = if2.expressify_statements().resolve_progn()
assert isinstance(if2r, ProgN) # Bad
if2m = Module(if2)
if2r = if2m.expressify_statements().resolve_progn()
assert isinstance(if2r, Module) # Good
if2r.validate()
assert if2r.emit() == '''x = 2
if x:
return 5'''
if3 = Module(
If(Assign([Name('x')], Num(2)), [Assign([Name('y')], Name('x'))]))
if3r = if3.expressify_statements().resolve_progn()
if3r.validate()
assert if3r.emit() == '''x = 2
if x:
y = x'''
assert if3r.variables() == {'x', 'y'}
assert collection_equivalent(if3r._children[1]._children,
[Assign([Name('y')], Name('x')),
Name('x')])
if4 = If(Num(1), [Num(2)], [Num(3)])
assert if4.emit() == 'if 1:\n 2\nelse:\n 3'
if4v = if4.as_value()
assert isinstance(if4v, ProgN)
assert if4v.value() == Name('_gensym_0')
assert Module(if4v).resolve_progn().emit() == '''if 1:
_gensym_0 = 2
else:
_gensym_0 = 3'''
if5 = If(Num(1), [Assign([Name('x')], Num(2))], [Num(3)])
assert if5.emit() == 'if 1:\n x = 2\nelse:\n 3'
assert Module(if5.as_value()).resolve_progn().emit() == '''if 1:
x = 2
else:
x = 3'''
if6 = If(Num(1), [Num(2)], [Assign([Name('x')], Num(3))])
assert if6.emit() == 'if 1:\n 2\nelse:\n x = 3'
assert Module(if6.as_value()).resolve_progn().emit() == '''if 1:
x = 2
else:
x = 3'''
if7 = If(Num(1), [Assign([Name('y')], Num(2))],
[Assign([Name('x')], Num(3))])
assert if7.emit() == 'if 1:\n y = 2\nelse:\n x = 3'
assert Module(if7.as_value()).resolve_progn().emit() == '''if 1:
y = 2
else:
x = 3
y = x'''
lgr = Logger()
if8 = If(If(Assign([Name('x')], Num(2)), [Num(3)], [Num(4)]),
[Return(Num(5))])
assert_raises(TypeError, if8.validate)
print(if8.viewable().pretty())
ex = Module(if8).expressify_statements(logger=lgr)
print(ex.viewable().pretty())
re = ex.resolve_progn(logger=lgr)
print(re.viewable().pretty())
for depth, event in lgr.root[1].depth_first(yield_depth=True):
print('-' * 80)
print(event.display(depth))
print(lgr.plaintext())
assert len(lgr.nodes) > 10
re.validate()
assert re.emit() == '''x = 2
def test_progn():
p = ProgN()
assert_raises(PythonError, p.validate)
assert_raises(PythonError, p.value)
assert_raises(PythonError, p.valuify)
# assert_raises(NotImplementedError, p.as_value)
assert_raises(NotImplementedError, p.expressify_statements)
p = ProgN(Assign([Name('x')], Num(2)))
assert p.valuify() is p
assert p.value() == Name('x')
ppp = ProgN(Num(1),
ProgN(Num(2),
ProgN(Num(3)),
ProgN(Assign([Name('y')], Num(4)))))
assert ppp.value() == Name('y')
assert ppp.resolve_progn() == ProgN(Num(1),
Num(2),
Num(3),
Assign([Name('y')], Num(4)))
p = ProgN(Num(2))
assert_raises(PythonError, p.value)
pv = p.valuify()
assert pv == ProgN(Assign([Name('_gensym_0')], Num(2)))
assert pv.value() == Name('_gensym_0')
def _to_python_native(obj, **kwargs):
from syn.python.b import Num
if Num._attrs.types['n'].query(obj):
return Num(obj)
raise TypeError("Cannot compile: {}".format(obj))