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)
