def BUILD_MAP(self, instr): nitems = instr.oparg keys = [] values = [] for i in range(nitems): map_instrs = [] while 1: new_instr = self.ilst.pop(0) if new_instr.opname == 'STORE_MAP': break map_instrs.append(new_instr) items = self.decompile_block(map_instrs).stmnt() assert len(items) == 2 values.append(items[0]) keys.append(items[1]) list_ = _ast.Dict(keys=keys, values=values, lineno=instr.lineno, col_offset=0) self.ast_stack.append(list_)
class ConstructorMutableAttribsLineNumberFixture: definition_is_none = None definition_is_not_a_function = _ast.Pass constructor_with_empty_body = _ast.FunctionDef(name='__init__', body=[]) try: constructor_with_immutable = _ast.FunctionDef( name='__init__', body=[ _ast.Assign(lineno=1, value=_ast.Tuple(elts=[1, 2, 3])), _ast.Assign(lineno=2, value=_ast.Str(s='a')), ], ) except (AttributeError): constructor_with_immutable = _ast.FunctionDef( name='__init__', body=[ _ast.Assign(lineno=1, value=_ast.Tuple(elts=[1, 2, 3])), _ast.Assign(lineno=3, value=_ast.JoinedStr(values=None)), ], ) constructor_with_mutable = _ast.FunctionDef( name='__init__', body=[ _ast.Assign(lineno=1, value=_ast.List(elts=[1, 2, 3])), _ast.Assign(lineno=2, value=_ast.Set(elts=[1, 2, 3])), _ast.Assign(lineno=3, value=_ast.Dict(keys=['a'])), ], )
def make_const(i, bytecode): arg = bytecode[i][3] if isinstance(arg, basestring): return i, _ast.Str(arg) elif isinstance(arg, int) or isinstance(arg, float) or isinstance(arg, long): return i, _ast.Num(arg) elif isinstance(arg, dict): return i, _ast.Dict(arg.keys(), arg.values()) elif isinstance(arg, set): return i, _ast.Dict(arg) elif isinstance(arg, tuple): return i, _ast.Tuple(arg, _ast.Load()) elif isinstance(arg, list): return i, _ast.List(arg, _ast.Load()) elif isinstance(arg, bytes): return i, _ast.Bytes(arg) return i, None
def make_dict(i, bytecode): """ This is a trick. We don't try to resolve exactly what the dict contains, but just create a dict type with the proper number of args. """ logger.debug("i=%d, bytecode=\n%s", i, show_bytecode(bytecode)) num_keys = -1 if bytecode[i][2] == BUILD_MAP: return i, _ast.Dict([], []) else: keys, values = [], [] j = i - 1 build_map_idx = i - 1 while j >= 0: if bytecode[j][2] == BUILD_MAP: num_keys = bytecode[j][3] build_map_idx = j j -= 1 return build_map_idx, _ast.Dict(range(num_keys), [None] * num_keys) return build_map_idx, None
def Dict(keys=(), values=()): """Creates an _ast.Dict node. This represents a dict literal. Args: keys: A list of keys as nodes. Must be the same length as values. values: A list of values as nodes. Must be the same length as values. Raises: ValueError: If len(keys) != len(values). Returns: An _ast.Dict node. """ if len(keys) != len(values): raise ValueError('len(keys)={} != len(values)={}'.format( len(keys), len(values))) return _ast.Dict(list(keys), list(values))
def dict_expr(keys: List[_ast.expr], values: List[_ast.expr]) -> _ast.Dict: return _ast.Dict(keys=keys, values=values)
def test_return_value_is_filled_dict(): # when method return {'1': '2'} assert ReturnedExpression( _ast.Return(value=_ast.Dict(keys=['1'], values=['2']), lineno=1), ).value_not_none() is True
def test_return_value_is_empty_dict(): # when method return {} assert ReturnedExpression( _ast.Return(value=_ast.Dict(keys=[], values=[]), lineno=1), ).value_not_none() is False