def test_return_value_is_filled_dict_by_keyword(): # when method return dict(a='b') try: assert ReturnedExpression( _ast.Return( value=_ast.Call( func=_ast.Name(id='dict', ctx=_ast.Load()), args=[], keywords=[_ast.keyword(arg='a', value=_ast.Str(s='b'))], ), lineno=1, ), ).value_not_none() is True except (AttributeError): assert ReturnedExpression( _ast.Return( value=_ast.Call( func=_ast.Name(id='dict', ctx=_ast.Load()), args=[], keywords=[ _ast.keyword(arg='a', value=_ast.JoinedStr(values=['a', 'b'])) ], ), lineno=1, ), ).value_not_none() is True
def make_call(i, bytecode): op = bytecode[i][2] def get_call_arg_length(op, arg): na = arg & 0xff # num args nk = (arg >> 8) & 0xff # num keywords return na, nk, na + 2 * nk + CALL_EXTRA_ARG_OFFSET[op] has_var, has_kw = 0, 0 if op in (CALL_FUNCTION_VAR, CALL_FUNCTION_VAR_KW): has_var = 1 if op in (CALL_FUNCTION_KW, CALL_FUNCTION_VAR_KW): has_kw = 1 op, arg = bytecode[i][2], bytecode[i][3] num_args, num_keywords, offset = get_call_arg_length(op, arg) func, args, keywords, starargs, kwargs = None, None, None, None, None if has_kw > 0: i, kwargs = Statement.make_expr(i - 1, bytecode) if has_var > 0: i, starargs = Statement.make_expr(i - 1, bytecode) # Handle keywords if num_keywords > 0: keywords = [] while num_keywords > 0: i, kw_value = Statement.make_expr(i - 1, bytecode) i, kw_name = Statement.make_expr(i - 1, bytecode) keywords.insert(0, _ast.keyword(kw_name, kw_value)) num_keywords -= 1 finger = i - 1 if num_args > 0: n = num_args - 1 args = [None] * num_args for k in range(num_args): cur_stack = 0 loc_bytecode = [] is_first = True while True: op, arg = bytecode[finger][2], bytecode[finger][3] pop, push = get_stack_effect(op, arg) cur_stack -= (pop - push) if not is_first else pop is_first = False loc_bytecode.insert(0, bytecode[finger]) if cur_stack == 0: break finger -= 1 _, args[n] = Statement.make_expr(len(loc_bytecode) - 1, loc_bytecode) n -= 1 finger -= 1 _, func = Statement.make_expr(finger, bytecode) call = _ast.Call(func, args, keywords, starargs, kwargs) logger.debug("\n%s", dump(call)) return finger, call
def grab(tree, **kw): keywords = [keyword(k.id, Name(k.id, Load())) for k in tree.elts] return Call( Name('dict', Load()), [], keywords, )
def decorate(fun, args): """Create a decorator call. To get jit(nopython=True), call decorate('jit', {"nopython": "True"}""" return Call(func=Name(id=fun, ctx=Load()), args=[], keywords=list( map(lambda kv: keyword(arg=kv[0], value=read(kv[1])), itr(args))), starargs=None, kwargs=None)
def Call(caller, args=(), keys=(), values=(), starargs=None, kwargs=None): """Creates an _ast.Call node. Args: caller: Either a node of the appropriate type (_ast.Str, _ast.Name, or _ast.Attribute), or a dot-separated string. args: A list of args. keys: A list of keys, must be the same length as values. values: A list of values, correspond to keys. starargs: A node with a star in front of it. Passing a string will be interpreted as a VarReference. kwargs: A node with two stars in front of it. Passing a string will be interpreted as a VarReference. Raises: ValueError: If len(keys) != len(values) or caller is not the right type. Returns: An _ast.Call object. """ if len(keys) != len(values): raise ValueError('len(keys)={} != len(values)={}'.format( len(keys), len(values))) if isinstance(caller, str): caller = VarReference(*caller.split('.')) if not isinstance(caller, (_ast.Str, _ast.Name, _ast.Attribute)): raise ValueError('caller must be a: \n' '1. string\n' '2. _ast.Str node\n' '3. _ast.Name node\n' '4. _ast.Attr node\n' 'not {}'.format(caller)) keywords = [ _ast.keyword(arg=key, value=val) for key, val in zip(keys, values) ] args = [_WrapWithName(arg, ctx_type=CtxEnum.LOAD) for arg in args] if isinstance(starargs, str): starargs = VarReference(*starargs.split('.')) if isinstance(kwargs, str): kwargs = VarReference(*kwargs.split('.')) return _ast.Call(func=caller, args=args, keywords=keywords, starargs=starargs, kwargs=kwargs)
def CALL_FUNCTION(self, instr): nkwargs = instr.oparg >> 8 nargs = (~(nkwargs << 8)) & instr.oparg args = [] keywords = [] for _ in range(nkwargs): expr = self.ast_stack.pop() name = self.ast_stack.pop() keyword = _ast.keyword(arg=name.s, value=expr, lineno=instr.lineno) keywords.insert(0, keyword) for _ in range(nargs): arg = self.ast_stack.pop() args.insert(0, arg) if len(args) == 1 and isinstance(args[0], (_ast.FunctionDef, _ast.ClassDef)): function = args[0] if function.decorator_list is None: function.decorator_list = [] node = self.ast_stack.pop() function.decorator_list.insert(0, node) self.ast_stack.append(function) return node = self.ast_stack.pop() callfunc = _ast.Call( func=node, args=args, keywords=keywords, starargs=None, kwargs=None, lineno=instr.lineno, col_offset=0, ) self.ast_stack.append(callfunc)
def CALL_FUNCTION(self, instr): nkwargs = instr.oparg >> 8 nargs = (~(nkwargs << 8)) & instr.oparg args = [] keywords = [] for _ in range(nkwargs): expr = self.ast_stack.pop() name = self.ast_stack.pop() keyword = _ast.keyword(arg=name.s, value=expr, lineno=instr.lineno) keywords.insert(0, keyword) for _ in range(nargs): arg = self.ast_stack.pop() args.insert(0, arg) if len(args) == 1 and isinstance(args[0], (_ast.FunctionDef, _ast.ClassDef)): function = args[0] if function.decorator_list is None: function.decorator_list = [] node = self.ast_stack.pop() function.decorator_list.insert(0, node) self.ast_stack.append(function) return node = self.ast_stack.pop() callfunc = _ast.Call(func=node, args=args, keywords=keywords, starargs=None, kwargs=None, lineno=instr.lineno, col_offset=0) self.ast_stack.append(callfunc)
def keyword_expr(value: _ast.expr) -> _ast.keyword: return _ast.keyword(value=value, arg=None)
def __init__(self, **kwargs): self._prefix = kwargs.pop('prefix', '') self._kwargs = [keyword(arg=key, value=ast_smart(value)) for key, value in kwargs.items()]
def keyword_arg(name, value): "AST keyword value." value = value if isinstance(value, AST) else Str(value) return keyword(arg=name, value=value)