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)
