def visit_Print(self, n):
keywords = []
if n.dest is not None:
keywords.append(ast3.keyword("file", self.visit(n.dest)))
if not n.nl:
keywords.append(ast3.keyword("end", ast3.Str(" ", lineno=n.lineno, col_offset=-1)))
return ast3.Expr(ast3.Call(ast3.Name("print", ast3.Load(), lineno=n.lineno, col_offset=-1),
self.visit(n.values),
keywords,
lineno=n.lineno, col_offset=-1))
def visit_Print(self, n):
keywords = []
if n.dest is not None:
keywords.append(ast3.keyword("file", self.visit(n.dest)))
if not n.nl:
keywords.append(ast3.keyword("end", ast3.Str(" ", lineno=n.lineno, col_offset=-1)))
return ast3.Expr(ast3.Call(ast3.Name("print", ast3.Load(), lineno=n.lineno, col_offset=-1),
self.visit(n.values),
keywords,
lineno=n.lineno, col_offset=-1))
def visit_Compare(self, node: ast3.Compare) -> VisitorOutput:
"Transforms a comparision into a function call. E.g. `ABC == MNO` into `ABC.eq(MNO)`"
assert len(
node.ops
) == 1, "Pytropos only supports comparisions of two values at the time"
self.generic_visit(node)
op_type = type(node.ops[0])
if op_type not in compopt:
raise AstTransformerError(
f"Pytropos doesn't support the comparison {type(op_type)} yet, sorry :("
)
op_str = compopt[op_type]
new_v = ast3.Call(func=ast3.Attribute(value=node.left,
attr=op_str,
ctx=ast3.Load()),
args=[node.comparators[0]],
keywords=[
ast3.keyword(arg='pos',
value=pos_as_tuple(node),
ctx=ast3.Load())
])
return new_v
def visit_Cast(self, node): # pylint: disable=invalid-name
"""Transform C cast into cast() function call."""
to_type = self.visit(node.to_type)
expr = self.visit(node.expr)
_ = self.visit(node.coord)
return typed_ast3.Call(func=typed_ast3.Name(id='cast', ctx=typed_ast3.Load()), args=[expr],
keywords=[typed_ast3.keyword(arg='type', value=to_type)])
def make_numpy_constructor(function: str, arg: typed_ast3.AST,
data_type: typed_ast3.AST) -> typed_ast3.Call:
return typed_ast3.Call(
func=typed_ast3.Attribute(
value=typed_ast3.Name(id='np', ctx=typed_ast3.Load()),
attr=function, ctx=typed_ast3.Load()),
args=[arg],
keywords=[typed_ast3.keyword(arg='dtype', value=data_type)])
def visit_Call(self, n):
args = self.visit(n.args)
if n.starargs is not None:
args.append(ast3.Starred(self.visit(n.starargs), ast3.Load(), lineno=n.starargs.lineno, col_offset=n.starargs.col_offset))
keywords = self.visit(n.keywords)
if n.kwargs is not None:
keywords.append(ast3.keyword(None, self.visit(n.kwargs)))
return ast3.Call(self.visit(n.func),
args,
keywords)
def visit_Call(self, n):
args = self.visit(n.args)
if n.starargs is not None:
args.append(ast3.Starred(self.visit(n.starargs), ast3.Load(), lineno=n.starargs.lineno, col_offset=n.starargs.col_offset))
keywords = self.visit(n.keywords)
if n.kwargs is not None:
keywords.append(ast3.keyword(None, self.visit(n.kwargs)))
return ast3.Call(self.visit(n.func),
args,
keywords)
def visit_FunctionDef(self, node: FunctionDef) -> FunctionDef:
if node.name == 'main':
kw = []
if kwargs:
for k, v in kwargs.items():
kw.append(keyword(arg=k, value=v))
if kwargs2parse:
for k, v in kwargs2parse.items():
kw.append(keyword(arg=k, value=parse(v)))
node.body.insert(
0,
Assign(targets=[Name(id=name, ctx=Store())],
value=Call(func=Name(id=cls, ctx=Load()),
args=[],
keywords=kw)))
return node
def test_ast_validator_synthetic(self):
examples = ((typed_ast3,
typed_ast3.FormattedValue(typed_ast3.Str('value'), None,
None)),
(typed_ast3,
typed_ast3.keyword(
None, typed_ast3.Name('value', typed_ast3.Load()))),
(typed_ast3,
typed_ast3.ImportFrom('pkg',
[typed_ast3.alias('module', None)],
None)))
for fields_first, (ast_module, example) in itertools.product(
(False, True), examples):
with self.subTest(example=example):
# tree = ast_module.Expression(example)
validator = AstValidator[ast_module](fields_first=fields_first,
mode=None)
validator.visit(example)
def visit_BinOp(self, node: ast3.BinOp) -> VisitorOutput:
"Transforms a binary operation into a function call. E.g. `ABC == MNO` into `ABC.eq(MNO)`"
self.generic_visit(node)
op_type = type(node.op)
if op_type not in operations:
raise AstTransformerError(
f"Pytropos doesn't support the operation {type(op_type)} yet, sorry :("
)
op_str = operations[op_type]
new_v = ast3.Call(func=ast3.Attribute(value=node.left,
attr=op_str,
ctx=ast3.Load()),
args=[node.right],
keywords=[
ast3.keyword(arg='pos',
value=pos_as_tuple(node),
ctx=ast3.Load())
])
return new_v
def visit_Call(self, node: ast3.Call) -> VisitorOutput:
"""Transforms a call to be handled by Pytropos
For example, it converts::
func(3, b, *c, d=2)
into::
func.call(st, Args((pt.int(3), st['b']), st['c'], {'d': pt.int(2)}), pos=...)"""
self.generic_visit(node)
args = [] # type: List[ast3.expr]
starred = None # type: Optional[ast3.expr]
kwargs_keys = [] # type: List[ast3.expr]
kwargs_values = [] # type: List[ast3.expr]
for i, v in enumerate(node.args):
if isinstance(v, ast3.Starred):
starred = v.value
break
args.append(v)
# In case a starred expresion was found
else:
# If there is something after the starred expr
if len(node.args) > 0 and i < len(node.args) - 1:
raise AstTransformerError(
f"{self.filename}:{v.lineno}:{v.col_offset}: Fatal Error: "
"Only one expression starred is allowed when calling a function"
)
for val in node.keywords:
if val.arg is None:
raise AstTransformerError(
f"{self.filename}:{v.lineno}:{v.col_offset}: Fatal Error: "
"No kargs parameters is allowed when calling a function")
kwargs_keys.append(ast3.Str(s=val.arg))
kwargs_values.append(val.value)
new_call_args = [
ast3.Tuple(
elts=args,
ctx=ast3.Load(),
),
] # type: List[ast3.expr]
if kwargs_keys:
new_call_args.append(
ast3.NameConstant(value=None) if starred is None else starred)
new_call_args.append(
ast3.Dict(keys=kwargs_keys, values=kwargs_values))
elif starred is not None:
new_call_args.append(starred)
return ast3.Call(
func=ast3.Attribute(
value=node.func,
attr='call',
ctx=ast3.Load(),
),
args=[
ast3.Name(id='st', ctx=ast3.Load()),
ast3.Call(
func=ast3.Attribute(
value=ast3.Name(id='pt', ctx=ast3.Load()),
attr='Args',
ctx=ast3.Load(),
),
args=new_call_args,
keywords=[],
)
],
keywords=[
ast3.keyword(arg='pos',
value=pos_as_tuple(node),
ctx=ast3.Load())
],
)
