def __call__(self, *args, **kwargs):
if kwargs:
raise TypingError("List() takes no keyword arguments")
elif args:
if not 0 <= len(args) <= 1:
raise TypingError(
"List() expected at most 1 argument, got {}".format(
len(args)))
rt = types.ListType(_guess_dtype(args[0]))
self.attach_sig()
return Signature(rt, args, None, pysig=self.pysig)
else:
item_type = types.undefined
return types.ListType(item_type)
def test_type_alias(self):
Pair = py_typing.Tuple[int, int]
ListOfPairs = py_typing.List[Pair]
pair_nb_type = types.Tuple((self.int_nb_type, self.int_nb_type))
self.assertEqual(as_numba_type(Pair), pair_nb_type)
self.assertEqual(as_numba_type(ListOfPairs),
types.ListType(pair_nb_type))
def test_issue_list_type_key(self):
# https://github.com/numba/numba/issues/6397
class NoUniqueNameType(types.Dummy):
def __init__(self, param):
super(NoUniqueNameType, self).__init__('NoUniqueNameType')
self.param = param
@property
def key(self):
return self.param
no_unique_name_type_1 = NoUniqueNameType(1)
no_unique_name_type_2 = NoUniqueNameType(2)
for ty1 in (no_unique_name_type_1, no_unique_name_type_2):
for ty2 in (no_unique_name_type_1, no_unique_name_type_2):
self.assertIs(
types.ListType(ty1) == types.ListType(ty2), # noqa: E721
ty1 == ty2)
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_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 test_type_annotations(self):
spec = [("x", int32)]
@jitclass(spec)
class Test1(object):
x: int
y: pt.List[float]
def __init__(self):
pass
self._check_spec(spec, Test1, spec + [("y", types.ListType(float64))])
def test_list_as_item_in_list(self):
nested_type = types.ListType(types.int32)
@njit
def foo():
la = List.empty_list(nested_type)
lb = List.empty_list(types.int32)
lb.append(1)
la.append(lb)
return la
expected = foo.py_func()
got = foo()
self.assertEqual(expected, got)
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_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_list(typingctx, itemty, ptr):
"""Make a list struct with the given *ptr*
Parameters
----------
itemty: Type
Type of the item.
ptr : llvm pointer value
Points to the list object.
"""
list_ty = types.ListType(itemty.instance_type)
def codegen(context, builder, signature, args):
ptr = args[1]
ctor = cgutils.create_struct_proxy(list_ty)
lstruct = ctor(context, builder)
lstruct.data = ptr
_add_meminfo(context, builder, lstruct)
return lstruct._getvalue()
sig = list_ty(itemty, ptr)
return sig, codegen
def test_list_to_from_meminfo(self):
"""
Exercise listobject.{_as_meminfo, _from_meminfo}
"""
@njit
def boxer():
l = listobject.new_list(int32)
for i in range(10, 20):
l.append(i)
return listobject._as_meminfo(l)
lsttype = types.ListType(int32)
@njit
def unboxer(mi):
l = listobject._from_meminfo(mi, lsttype)
return l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9]
mi = boxer()
self.assertEqual(mi.refcount, 1)
received = list(unboxer(mi))
expected = list(range(10, 20))
self.assertEqual(received, expected)
def _initialise_list(self, item):
lsttype = types.ListType(typeof(item))
self._list_type, self._opaque = self._parse_arg(lsttype)
def typer():
return types.ListType(types.undefined)
