def test_dict_to_from_meminfo(self): """ Exercise dictobject.{_as_meminfo, _from_meminfo} """ @njit def make_content(nelem): for i in range(nelem): yield i, i + (i + 1) / 100 @njit def boxer(nelem): d = dictobject.new_dict(int32, float64) for k, v in make_content(nelem): d[k] = v return dictobject._as_meminfo(d) dcttype = types.DictType(int32, float64) @njit def unboxer(mi): d = dictobject._from_meminfo(mi, dcttype) return list(d.items()) mi = boxer(10) self.assertEqual(mi.refcount, 1) got = unboxer(mi) expected = list(make_content.py_func(10)) self.assertEqual(got, expected)
def test_dict_of_dict_int_keyval(self): def inner_numba_dict(): d = Dict.empty( key_type=types.intp, value_type=types.intp, ) return d d = Dict.empty( key_type=types.intp, value_type=types.DictType(types.intp, types.intp), ) def usecase(d, make_inner_dict): for i in range(100): mid = make_inner_dict() for j in range(i + 1): mid[j] = j * 10000 d[i] = mid return d got = usecase(d, inner_numba_dict) expect = usecase({}, dict) self.assertIsInstance(expect, dict) self.assertEqual(dict(got), expect) # Delete items for where in [12, 3, 6, 8, 10]: del got[where] del expect[where] self.assertEqual(dict(got), expect)
def test_dict_of_dict_npm(self): inner_dict_ty = types.DictType(types.intp, types.intp) @njit def inner_numba_dict(): d = Dict.empty( key_type=types.intp, value_type=types.intp, ) return d @njit def foo(count): d = Dict.empty( key_type=types.intp, value_type=inner_dict_ty, ) for i in range(count): d[i] = inner_numba_dict() for j in range(i + 1): d[i][j] = j return d d = foo(100) ct = 0 for k, dd in d.items(): ct += 1 self.assertEqual(len(dd), k + 1) for kk, vv in dd.items(): self.assertEqual(kk, vv) self.assertEqual(ct, 100)
def test_numba_types(self): numba_types = [ types.intp, types.boolean, types.ListType(types.float64), types.DictType(types.intp, types.Tuple([types.float32, types.float32])), ] for ty in numba_types: self.assertEqual(as_numba_type(ty), ty)
def build_map(context, builder, dict_type, item_types, items): if isinstance(dict_type, types.LiteralStrKeyDict): unliteral_tys = [x for x in dict_type.literal_value.values()] nbty = types.NamedTuple(unliteral_tys, dict_type.tuple_ty) values = [x[1] for x in items] # replace with make_tuple call? tup = context.get_constant_undef(nbty) literal_tys = [x for x in dict_type.literal_value.values()] # this is to deal with repeated keys value_index = dict_type.value_index if value_index is None: # 1:1 map keys:values value_indexer = range(len(values)) else: # 1:>1 map keys:values, e.g. {'a':1, 'a': 'foo'} value_indexer = value_index.values() for i, ix in enumerate(value_indexer): val = values[ix] casted = context.cast(builder, val, literal_tys[i], unliteral_tys[i]) tup = builder.insert_value(tup, casted, i) d = tup context.nrt.incref(builder, nbty, d) else: from numba.typed import Dict dt = types.DictType(dict_type.key_type, dict_type.value_type) kt, vt = dict_type.key_type, dict_type.value_type sig = typing.signature(dt) def make_dict(): return Dict.empty(kt, vt) d = context.compile_internal(builder, make_dict, sig, ()) if items: for (kt, vt), (k, v) in zip(item_types, items): sig = typing.signature(types.void, dt, kt, vt) args = d, k, v def put(d, k, v): d[k] = v context.compile_internal(builder, put, sig, args) return d
def ol_bar(x): self.assertTrue(isinstance(x, types.LiteralStrKeyDict)) dlv = x.literal_value inner_literal = { types.literal('g'): types.literal('h'), types.literal('i'): types.Array(types.float64, 1, 'C') } inner_dict = types.LiteralStrKeyDict(inner_literal) outer_literal = { types.literal('a'): types.LiteralList([ types.literal(1), types.literal('a'), types.DictType(types.unicode_type, types.intp, initial_value={'f': 1}), inner_dict ]), types.literal('b'): types.literal(2), types.literal('c'): types.List(types.complex128, reflected=False) } def check_same(a, b): if (isinstance(a, types.LiteralList) and isinstance(b, types.LiteralList)): for i, j in zip(a.literal_value, b.literal_value): check_same(a.literal_value, b.literal_value) elif (isinstance(a, list) and isinstance(b, list)): for i, j in zip(a, b): check_same(i, j) elif (isinstance(a, types.LiteralStrKeyDict) and isinstance(b, types.LiteralStrKeyDict)): for (ki, vi), (kj, vj) in zip(a.literal_value.items(), b.literal_value.items()): check_same(ki, kj) check_same(vi, vj) elif (isinstance(a, dict) and isinstance(b, dict)): for (ki, vi), (kj, vj) in zip(a.items(), b.items()): check_same(ki, kj) check_same(vi, vj) else: self.assertEqual(a, b) check_same(dlv, outer_literal) return lambda x: x
def _builtin_infer(self, py_type): # The type hierarchy of python typing library changes in 3.7. generic_type_check = _py_version_switch( (3, 7), lambda x: isinstance(x, py_typing._GenericAlias), lambda _: True, ) if not generic_type_check(py_type): return list_origin = _py_version_switch((3, 7), list, py_typing.List) dict_origin = _py_version_switch((3, 7), dict, py_typing.Dict) set_origin = _py_version_switch((3, 7), set, py_typing.Set) tuple_origin = _py_version_switch((3, 7), tuple, py_typing.Tuple) if getattr(py_type, "__origin__", None) is py_typing.Union: if len(py_type.__args__) != 2: raise errors.TypingError( "Cannot type Union of more than two types") (arg_1_py, arg_2_py) = py_type.__args__ if arg_2_py is type(None): # noqa: E721 return types.Optional(self.infer(arg_1_py)) elif arg_1_py is type(None): # noqa: E721 return types.Optional(self.infer(arg_2_py)) else: raise errors.TypingError( "Cannot type Union that is not an Optional " f"(neither type type {arg_2_py} is not NoneType") if getattr(py_type, "__origin__", None) is list_origin: (element_py, ) = py_type.__args__ return types.ListType(self.infer(element_py)) if getattr(py_type, "__origin__", None) is dict_origin: key_py, value_py = py_type.__args__ return types.DictType(self.infer(key_py), self.infer(value_py)) if getattr(py_type, "__origin__", None) is set_origin: (element_py, ) = py_type.__args__ return types.Set(self.infer(element_py)) if getattr(py_type, "__origin__", None) is tuple_origin: tys = tuple(map(self.infer, py_type.__args__)) return types.BaseTuple.from_types(tys)
def test_nested_containers(self): IntList = py_typing.List[int] self.assertEqual( as_numba_type(py_typing.List[IntList]), types.ListType(types.ListType(self.int_nb_type)), ) self.assertEqual( as_numba_type(py_typing.List[py_typing.Dict[float, bool]]), types.ListType( types.DictType(self.float_nb_type, self.bool_nb_type)), ) self.assertEqual( as_numba_type( py_typing.Set[py_typing.Tuple[py_typing.Optional[int], float]]), types.Set( types.Tuple( [types.Optional(self.int_nb_type), self.float_nb_type])), )
def test_single_containers(self): self.assertEqual( as_numba_type(py_typing.List[float]), types.ListType(self.float_nb_type), ) self.assertEqual( as_numba_type(py_typing.Dict[float, str]), types.DictType(self.float_nb_type, self.str_nb_type), ) self.assertEqual( as_numba_type(py_typing.Set[complex]), types.Set(self.complex_nb_type), ) self.assertEqual( as_numba_type(py_typing.Tuple[float, float]), types.Tuple([self.float_nb_type, self.float_nb_type]), ) self.assertEqual( as_numba_type(py_typing.Tuple[float, complex]), types.Tuple([self.float_nb_type, self.complex_nb_type]), )
def _make_dict(typingctx, keyty, valty, ptr): """Make a dictionary struct with the given *ptr* Parameters ---------- keyty, valty: Type Type of the key and value, respectively. ptr : llvm pointer value Points to the dictionary object. """ dict_ty = types.DictType(keyty.instance_type, valty.instance_type) def codegen(context, builder, signature, args): [_, _, ptr] = args ctor = cgutils.create_struct_proxy(dict_ty) dstruct = ctor(context, builder) dstruct.data = ptr alloc_size = context.get_abi_sizeof( context.get_value_type(types.voidptr), ) dtor = _imp_dtor(context, builder.module) meminfo = context.nrt.meminfo_alloc_dtor( builder, context.get_constant(types.uintp, alloc_size), dtor, ) data_pointer = context.nrt.meminfo_data(builder, meminfo) data_pointer = builder.bitcast(data_pointer, ll_dict_type.as_pointer()) builder.store(ptr, data_pointer) dstruct.meminfo = meminfo return dstruct._getvalue() sig = dict_ty(keyty, valty, ptr) return sig, codegen
def typer(): return types.DictType(types.undefined, types.undefined)
def _initialise_dict(self, key, value): dcttype = types.DictType(typeof(key), typeof(value)) self._dict_type, self._opaque = self._parse_arg(dcttype)