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, )