def _create_args(self,
stmt: param_stmt.ParametrizedStatement) -> List[ast.expr]:
"""Creates the positional arguments, i.e., POSITIONAL_ONLY,
POSITIONAL_OR_KEYWORD and VAR_POSITIONAL.
Args:
stmt: The parameterised statement
Returns:
A list of AST statements
"""
args: List[ast.expr] = []
gen_callable: GenericCallableAccessibleObject = cast(
GenericCallableAccessibleObject, stmt.accessible_object())
for param_name in gen_callable.inferred_signature.parameters:
if param_name in stmt.args:
param_kind = gen_callable.inferred_signature.signature.parameters[
param_name].kind
if param_kind in (
Parameter.POSITIONAL_ONLY,
Parameter.POSITIONAL_OR_KEYWORD,
):
args.append(
au.create_var_name(self._variable_names,
stmt.args[param_name], True))
elif param_kind == Parameter.VAR_POSITIONAL:
# Append *args, if necessary.
args.append(
ast.Starred(
value=au.create_var_name(self._variable_names,
stmt.args[param_name],
True),
ctx=ast.Load(),
))
return args
def _create_kw_args(
self, stmt: param_stmt.ParametrizedStatement) -> List[ast.keyword]:
"""Creates the keyword arguments, i.e., KEYWORD_ONLY or VAR_KEYWORD.
Args:
stmt: The parameterised statement
Returns:
A list of AST statements
"""
kwargs = []
gen_callable: GenericCallableAccessibleObject = cast(
GenericCallableAccessibleObject, stmt.accessible_object())
for param_name in gen_callable.inferred_signature.parameters:
if param_name in stmt.args:
param_kind = gen_callable.inferred_signature.signature.parameters[
param_name].kind
if param_kind == Parameter.KEYWORD_ONLY:
kwargs.append(
ast.keyword(
arg=param_name,
value=au.create_var_name(self._variable_names,
stmt.args[param_name],
True),
))
elif param_kind == Parameter.VAR_KEYWORD:
# Append **kwargs, if necessary.
kwargs.append(
ast.keyword(
arg=None,
value=au.create_var_name(self._variable_names,
stmt.args[param_name],
True),
))
return kwargs
def visit_assignment_statement(
self, stmt: assign_stmt.AssignmentStatement) -> None:
self._ast_nodes.append(
ast.Assign(
targets=[
au.create_var_name(self._variable_names, stmt.ret_val,
False)
],
value=au.create_var_name(self._variable_names, stmt.rhs, True),
))
def visit_tuple_statement(self, stmt: coll_stmt.TupleStatement) -> None:
self._ast_nodes.append(
ast.Assign(
targets=[
au.create_var_name(self._variable_names, stmt.ret_val,
False)
],
value=ast.Tuple(
elts=[
au.create_var_name(self._variable_names, x, True)
for x in stmt.elements
],
ctx=ast.Load(),
),
))
def _create_float_delta_assert(self, var: vr.VariableReference,
value: Any) -> ast.Assert:
self._common_modules.add("math")
# TODO(fk) maybe use something more specific for pytest or UnitTest?
return ast.Assert(
test=ast.Call(
func=ast.Attribute(
value=ast.Name(id="math", ctx=ast.Load()),
attr="isclose",
ctx=ast.Load(),
),
args=[
au.create_var_name(self._variable_names, var, load=True),
ast.Constant(value=value, kind=None),
],
keywords=[
ast.keyword(
arg="abs_tol",
value=ast.Constant(
value=config.configuration.float_precision,
kind=None),
)
],
),
msg=None,
)
def visit_dict_statement(self, stmt: coll_stmt.DictStatement) -> None:
self._ast_nodes.append(
ast.Assign(
targets=[
au.create_var_name(self._variable_names, stmt.ret_val,
False)
],
value=ast.Dict(
keys=[
au.create_var_name(self._variable_names, x[0], True)
for x in stmt.elements
],
values=[
au.create_var_name(self._variable_names, x[1], True)
for x in stmt.elements
],
),
))
def _create_constant_assert(self, var: vr.VariableReference,
operator: ast.cmpop, value: Any) -> ast.Assert:
return ast.Assert(
test=ast.Compare(
left=au.create_var_name(self._variable_names, var, load=True),
ops=[operator],
comparators=[ast.Constant(value=value, kind=None)],
),
msg=None,
)
def visit_method_statement(self, stmt: param_stmt.MethodStatement) -> None:
call = ast.Call(
func=ast.Attribute(
attr=stmt.accessible_object().callable.__name__,
ctx=ast.Load(),
value=au.create_var_name(self._variable_names, stmt.callee,
True),
),
args=self._create_args(stmt),
keywords=self._create_kw_args(stmt),
)
if stmt.ret_val.is_none_type():
node: ast.stmt = ast.Expr(value=call)
else:
node = ast.Assign(
targets=[
au.create_var_name(self._variable_names, stmt.ret_val,
False)
],
value=call,
)
self._ast_nodes.append(node)
def _create_args(self,
stmt: param_stmt.ParametrizedStatement) -> List[ast.Name]:
"""Creates the positional arguments.
Args:
stmt: The parameterised statement
Returns:
A list of AST statements
"""
args = []
for arg in stmt.args:
args.append(au.create_var_name(self._variable_names, arg, True))
return args
def _create_constant(self, stmt: prim_stmt.PrimitiveStatement) -> ast.stmt:
"""All primitive values are constants.
Args:
stmt: The primitive statement
Returns:
The matching AST statement
"""
return ast.Assign(
targets=[
au.create_var_name(self._variable_names, stmt.ret_val, False)
],
value=ast.Constant(value=stmt.value),
)
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 visit_field_statement(self, stmt: field_stmt.FieldStatement) -> None:
self._ast_nodes.append(
ast.Assign(
targets=[
ast.Name(
id=self._variable_names.get_name(stmt.ret_val),
ctx=ast.Store(),
)
],
value=ast.Attribute(
attr=stmt.field,
ctx=ast.Load(),
value=au.create_var_name(self._variable_names, stmt.source,
True),
),
))
def _create_kw_args(
self, stmt: param_stmt.ParametrizedStatement) -> List[ast.keyword]:
"""Creates the keyword arguments.
Args:
stmt: The parameterised statement
Returns:
A list of AST statements
"""
kwargs = []
for name, value in stmt.kwargs.items():
kwargs.append(
ast.keyword(
arg=name,
value=au.create_var_name(self._variable_names, value,
True),
))
return kwargs
def visit_constructor_statement(
self, stmt: param_stmt.ConstructorStatement) -> None:
owner = stmt.accessible_object().owner
assert owner
self._ast_nodes.append(
ast.Assign(
targets=[
au.create_var_name(self._variable_names, stmt.ret_val,
False)
],
value=ast.Call(
func=ast.Attribute(
attr=owner.__name__,
ctx=ast.Load(),
value=self._create_module_alias(owner.__module__),
),
args=self._create_args(stmt),
keywords=self._create_kw_args(stmt),
),
))
def _create_float_delta_assert(
self, var: vr.VariableReference, value: Any
) -> ast.Assert:
self._common_modules.add("pytest")
return ast.Assert(
test=ast.Compare(
left=au.create_var_name(self._variable_names, var, load=True),
ops=[ast.Eq()],
comparators=[
ast.Call(
func=ast.Attribute(
value=ast.Name(id="pytest", ctx=ast.Load()),
attr="approx",
ctx=ast.Load(),
),
args=[
ast.Constant(value=value, kind=None),
],
keywords=[
ast.keyword(
arg="abs",
value=ast.Constant(
value=config.configuration.float_precision,
kind=None,
),
),
ast.keyword(
arg="rel",
value=ast.Constant(
value=config.configuration.float_precision,
kind=None,
),
),
],
),
],
),
msg=None,
)
