def test_type():
content = awkward1.layout.NumpyArray(numpy.array([0.0, 1.1, 2.2, 3.3, 4.4]))
index = awkward1.layout.Index32(numpy.array([2, 2, 0, 3, 4], dtype=numpy.int32))
array = awkward1.layout.IndexedArray32(index, content)
assert awkward1.type(array) == awkward1.types.PrimitiveType("float64")
array = awkward1.layout.IndexedOptionArray32(index, content)
assert awkward1.type(array) == awkward1.types.OptionType(awkward1.types.PrimitiveType("float64"))
def test_UnmaskedArray():
content = awkward1.layout.NumpyArray(
numpy.array([1.1, 2.2, 3.3, 4.4, 5.5], dtype=numpy.float64))
array = awkward1.Array(awkward1.layout.UnmaskedArray(content))
assert awkward1.to_list(array) == [1.1, 2.2, 3.3, 4.4, 5.5]
assert str(awkward1.type(array)) == "5 * ?float64"
@numba.njit
def f1(x):
return 3.14
f1(array)
@numba.njit
def f2(x):
return x
y = f2(array)
assert isinstance(y.layout, awkward1.layout.UnmaskedArray)
assert awkward1.to_list(y) == awkward1.to_list(array)
assert str(awkward1.type(y)) == str(awkward1.type(array))
@numba.njit
def f3(x, i):
return x[i]
assert [f3(array, i)
for i in range(len(array))] == [1.1, 2.2, 3.3, 4.4, 5.5]
def test_arrow_nomask():
array = awkward1.Array([1.1, 2.2, 3.3, 4.4, None])
assert str(awkward1.type(awkward1.from_arrow(
awkward1.to_arrow(array)))) == "5 * ?float64"
assert str(
awkward1.type(awkward1.from_arrow(awkward1.to_arrow(
array[:-1])))) == "4 * ?float64"
def test_UnmaskedArray():
content = awkward1.layout.NumpyArray(numpy.array([1.1, 2.2, 3.3, 4.4, 5.5], dtype=numpy.float64))
array = awkward1.layout.UnmaskedArray(content)
assert awkward1.to_list(array) == [1.1, 2.2, 3.3, 4.4, 5.5]
assert str(awkward1.type(content)) == "float64"
assert str(awkward1.type(awkward1.Array(content))) == "5 * float64"
assert str(awkward1.type(array)) == "?float64"
assert str(awkward1.type(awkward1.Array(array))) == "5 * ?float64"
def test_ArrayBuilder_append_2():
# issue #415
A = awkward1.from_numpy(numpy.array([0, 1, 2], dtype=numpy.float32))
B = awkward1.from_numpy(numpy.array([0, 1], dtype=numpy.float32))
builder = awkward1.ArrayBuilder()
with builder.list():
builder.append(A.tolist())
with builder.list():
builder.append(A.tolist())
with builder.list():
pass
with builder.list():
builder.append(B.tolist())
assert builder.snapshot().tolist() == [[[0, 1, 2]], [[0, 1, 2]], [],
[[0, 1]]]
assert str(awkward1.type(builder.snapshot())) == "4 * var * var * float64"
builder = awkward1.ArrayBuilder()
with builder.list():
builder.append(A)
with builder.list():
builder.append(A)
with builder.list():
pass
with builder.list():
builder.append(B)
assert builder.snapshot().tolist() == [[[0, 1, 2]], [[0, 1, 2]], [],
[[0, 1]]]
assert str(awkward1.type(builder.snapshot())) == "4 * var * var * float32"
@numba.njit
def f1(builder, A, B):
builder.begin_list()
builder.append(A)
builder.end_list()
builder.begin_list()
builder.append(A)
builder.end_list()
builder.begin_list()
builder.end_list()
builder.begin_list()
builder.append(B)
builder.end_list()
return builder
assert f1(awkward1.ArrayBuilder(),
A, B).snapshot().tolist() == [[[0, 1, 2]], [[0, 1, 2]], [],
[[0, 1]]]
def test_string2():
content = awkward1.layout.NumpyArray(
numpy.array([ord(x) for x in "heythere"], dtype=numpy.uint8))
listoffsetarray = awkward1.layout.ListOffsetArray64(
awkward1.layout.Index64(numpy.array([0, 3, 3, 8])), content)
a = awkward1.Array(listoffsetarray, check_valid=True)
assert isinstance(a, awkward1.Array)
assert not isinstance(a, awkward1.behaviors.string.StringBehavior)
assert awkward1.to_list(a) == [[104, 101, 121], [],
[116, 104, 101, 114, 101]]
assert repr(awkward1.type(a)) == "3 * var * uint8"
assert repr(awkward1.type(a[0])) == "3 * uint8"
assert repr(awkward1.type(a[1])) == "0 * uint8"
assert repr(awkward1.type(a[2])) == "5 * uint8"
assert repr(
a
) == "<Array [[104, 101, 121], ... 101, 114, 101]] type='3 * var * uint8'>"
assert str(a) == "[[104, 101, 121], [], [116, 104, 101, 114, 101]]"
assert repr(a[0]) == "<Array [104, 101, 121] type='3 * uint8'>"
assert repr(a[1]) == "<Array [] type='0 * uint8'>"
assert repr(a[2]) == "<Array [116, 104, 101, 114, 101] type='5 * uint8'>"
content = awkward1.layout.NumpyArray(numpy.array(
[ord(x) for x in "heythere"], dtype=numpy.uint8),
parameters={
"__array__": "char",
"encoding": "utf-8"
})
listoffsetarray = awkward1.layout.ListOffsetArray64(
awkward1.layout.Index64(numpy.array([0, 3, 3, 8])),
content,
parameters={"__array__": "string"})
a = awkward1.Array(listoffsetarray, check_valid=True)
a = awkward1.Array(listoffsetarray, check_valid=True)
assert isinstance(a, awkward1.Array)
assert awkward1.to_list(a) == ['hey', '', 'there']
if py27:
assert str(a) == "[u'hey', u'', u'there']"
assert repr(a[0]) == "u'hey'"
assert repr(a[1]) == "u''"
assert repr(a[2]) == "u'there'"
else:
assert str(a) == "['hey', '', 'there']"
assert repr(a[0]) == "'hey'"
assert repr(a[1]) == "''"
assert repr(a[2]) == "'there'"
def test_highlevel():
array = awkward1.virtual(lambda: [[1.1, 2.2, 3.3], [], [4.4, 5.5]])
assert isinstance(array.layout, awkward1.layout.VirtualArray)
assert awkward1.to_list(array) == [[1.1, 2.2, 3.3], [], [4.4, 5.5]]
counter = [0]
def generate():
counter[0] += 1
return [[1.1, 2.2, 3.3], [], [4.4, 5.5]]
array = awkward1.virtual(generate,
length=3,
form={
"class": "ListOffsetArray64",
"offsets": "i64",
"content": "float64"
})
assert counter[0] == 0
assert len(array) == 3
assert counter[0] == 0
assert str(awkward1.type(array)) == "3 * var * float64"
assert counter[0] == 0
assert awkward1.to_list(array[2]) == [4.4, 5.5]
assert counter[0] == 1
def _ensure_flat(array, allow_missing=False):
"""Normalize an array to a flat numpy array or raise ValueError"""
if isinstance(array, awkward.AwkwardArray):
array = awkward1.from_awkward0(array)
elif not isinstance(array, (awkward1.Array, numpy.ndarray)):
raise ValueError("Expected a numpy or awkward array, received: %r" %
array)
aktype = awkward1.type(array)
if not isinstance(aktype, awkward1.types.ArrayType):
raise ValueError("Expected an array type, received: %r" % aktype)
isprimitive = isinstance(aktype.type, awkward1.types.PrimitiveType)
isoptionprimitive = isinstance(
aktype.type, awkward1.types.OptionType) and isinstance(
aktype.type.type, awkward1.types.PrimitiveType)
if allow_missing and not (isprimitive or isoptionprimitive):
raise ValueError(
"Expected an array of type N * primitive or N * ?primitive, received: %r"
% aktype)
if not (allow_missing or isprimitive):
raise ValueError(
"Expected an array of type N * primitive, received: %r" % aktype)
if isinstance(array, awkward1.Array):
array = awkward1.to_numpy(array, allow_missing=allow_missing)
return array
def test_regular():
regular = awkward1.Array(numpy.array([[i, i] for i in range(10)], dtype=numpy.int64))
assert str(regular.type) == "10 * 2 * int64"
assert awkward1.to_list(awkward1.to_regular(regular)) == awkward1.to_list(regular)
assert awkward1.type(awkward1.to_regular(regular)) == awkward1.type(regular)
irregular = awkward1.from_regular(regular)
assert awkward1.to_list(irregular) == awkward1.to_list(regular)
assert str(irregular.type) == "10 * var * int64"
assert awkward1.to_list(awkward1.from_regular(irregular)) == awkward1.to_list(irregular)
assert awkward1.type(awkward1.from_regular(irregular)) == awkward1.type(irregular)
reregular = awkward1.to_regular(irregular)
assert awkward1.to_list(reregular) == awkward1.to_list(regular)
assert str(reregular.type) == "10 * 2 * int64"
def test_RegularArray_and_ListArray():
content = awkward1.layout.NumpyArray(numpy.array([0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]));
offsets = awkward1.layout.Index64(numpy.array([0, 3, 3, 5, 6, 10, 10]))
listoffsetarray = awkward1.layout.ListOffsetArray64(offsets, content)
regulararray = awkward1.layout.RegularArray(listoffsetarray, 2)
starts = awkward1.layout.Index64(numpy.array([0, 1]))
stops = awkward1.layout.Index64(numpy.array([2, 3]))
listarray = awkward1.layout.ListArray64(starts, stops, regulararray)
assert str(awkward1.type(content)) == "float64"
assert str(awkward1.type(regulararray)) == "2 * var * float64"
assert str(awkward1.type(listarray)) == "var * 2 * var * float64"
regulararray_int8 = awkward1.values_astype(regulararray, 'int8', highlevel=False)
assert str(awkward1.type(regulararray_int8)) == "2 * var * int8"
listarray_bool = awkward1.values_astype(listarray, 'bool', highlevel=False)
assert str(awkward1.type(listarray_bool)) == "var * 2 * var * bool"
def test_regular_deep():
regular = awkward1.Array(numpy.array([[[i, i, i], [i, i, i]] for i in range(10)], dtype=numpy.int64))
assert str(regular.type) == "10 * 2 * 3 * int64"
irregular = awkward1.from_regular(regular, axis=1)
assert awkward1.to_list(irregular) == awkward1.to_list(regular)
assert str(irregular.type) == "10 * var * 3 * int64"
reregular = awkward1.to_regular(irregular, axis=1)
assert awkward1.to_list(reregular) == awkward1.to_list(regular)
assert str(reregular.type) == "10 * 2 * 3 * int64"
irregular = awkward1.from_regular(regular, axis=2)
assert awkward1.to_list(irregular) == awkward1.to_list(regular)
assert str(irregular.type) == "10 * 2 * var * int64"
reregular = awkward1.to_regular(irregular, axis=2)
assert awkward1.to_list(reregular) == awkward1.to_list(regular)
assert str(reregular.type) == "10 * 2 * 3 * int64"
irregular = awkward1.from_regular(regular, axis=-1)
assert awkward1.to_list(irregular) == awkward1.to_list(regular)
assert str(irregular.type) == "10 * 2 * var * int64"
reregular = awkward1.to_regular(irregular, axis=-1)
assert awkward1.to_list(reregular) == awkward1.to_list(regular)
assert str(reregular.type) == "10 * 2 * 3 * int64"
irregular = awkward1.from_regular(regular, axis=-2)
assert awkward1.to_list(irregular) == awkward1.to_list(regular)
assert str(irregular.type) == "10 * var * 3 * int64"
reregular = awkward1.to_regular(irregular, axis=-2)
assert awkward1.to_list(reregular) == awkward1.to_list(regular)
assert str(reregular.type) == "10 * 2 * 3 * int64"
with pytest.raises(ValueError):
awkward1.from_regular(regular, axis=-3)
assert awkward1.to_list(awkward1.from_regular(regular, axis=0)) == awkward1.to_list(regular)
assert awkward1.type(awkward1.from_regular(regular, axis=0)) == awkward1.type(regular)
def test_rpad_and_clip_list_array():
content = awkward1.layout.NumpyArray(
numpy.array([0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]))
starts = awkward1.layout.Index64(numpy.array([0, 3, 4, 5, 8]))
stops = awkward1.layout.Index64(numpy.array([3, 3, 6, 8, 9]))
array = awkward1.layout.ListArray64(starts, stops, content)
assert awkward1.to_list(array) == [[0.0, 1.1, 2.2], [], [4.4, 5.5],
[5.5, 6.6, 7.7], [8.8]]
assert awkward1.to_list(array.rpad_and_clip(1, 0)) == [[0.0, 1.1, 2.2]]
assert str("option[") + str(awkward1.type(array)) + str("]") == str(
awkward1.type(array.rpad_and_clip(1, 0)))
assert awkward1.to_list(array.rpad_and_clip(2, 0)) == [[0.0, 1.1, 2.2], []]
assert str("option[") + str(awkward1.type(array)) + str("]") == str(
awkward1.type(array.rpad_and_clip(2, 0)))
assert awkward1.to_list(array.rpad_and_clip(7, 0)) == [[0.0, 1.1, 2.2], [],
[4.4, 5.5],
[5.5, 6.6, 7.7],
[8.8], None, None]
assert str("option[") + str(awkward1.type(array)) + str("]") == str(
awkward1.type(array.rpad_and_clip(7, 0)))
assert awkward1.to_list(array.rpad_and_clip(1, 1)) == [[0.0], [None],
[4.4], [5.5], [8.8]]
assert awkward1.to_list(array.rpad_and_clip(2, 1)) == [[0.0, 1.1],
[None, None],
[4.4, 5.5],
[5.5, 6.6],
[8.8, None]]
def test_rpad_and_clip_listoffset_array():
content = awkward1.layout.NumpyArray(
numpy.array([0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]))
offsets = awkward1.layout.Index64(numpy.array([0, 3, 3, 5, 6, 10, 10]))
listoffsetarray = awkward1.layout.ListOffsetArray64(offsets, content)
assert awkward1.to_list(listoffsetarray) == [[0.0, 1.1, 2.2], [],
[3.3, 4.4], [5.5],
[6.6, 7.7, 8.8, 9.9], []]
assert awkward1.to_list(listoffsetarray.rpad_and_clip(
3, 0)) == [[0.0, 1.1, 2.2], [], [3.3, 4.4]]
assert str("option[") + str(
awkward1.type(listoffsetarray)) + str("]") == str(
awkward1.type(listoffsetarray.rpad_and_clip(3, 0)))
assert awkward1.to_list(listoffsetarray.rpad_and_clip(
7, 0)) == [[0.0, 1.1, 2.2], [], [3.3, 4.4], [5.5],
[6.6, 7.7, 8.8, 9.9], [], None]
assert str("option[") + str(
awkward1.type(listoffsetarray)) + str("]") == str(
awkward1.type(listoffsetarray.rpad_and_clip(7, 0)))
assert awkward1.to_list(listoffsetarray.rpad_and_clip(
5, 1)) == [[0.0, 1.1, 2.2, None, None], [None, None, None, None, None],
[3.3, 4.4, None, None, None], [5.5, None, None, None, None],
[6.6, 7.7, 8.8, 9.9, None], [None, None, None, None, None]]
assert str(awkward1.type(listoffsetarray.rpad(5, 1))) == "var * ?float64"
assert str(awkward1.type(listoffsetarray.rpad_and_clip(
5, 1))) == "5 * ?float64"
assert awkward1.to_list(listoffsetarray.rpad_and_clip(1, 1)) == [[0.0],
[None],
[3.3],
[5.5],
[6.6],
[None]]
content = awkward1.layout.NumpyArray(numpy.array([1.5, 3.3]))
index = awkward1.layout.Index64(
numpy.array([
0, -3, 1, -2, 1, 0, 0, -3, -13, 0, 1, 1, 0, 1, 1, 1, 1, -10, 0, -1,
0, 0, 0, 1, -1, 1, 1
]))
indexedarray = awkward1.layout.IndexedOptionArray64(index, content)
offsets = awkward1.layout.Index64(numpy.array([14, 15, 15, 15, 26, 26,
26]))
listoffsetarray = awkward1.layout.ListOffsetArray64(offsets, indexedarray)
assert awkward1.to_list(listoffsetarray) == [[
3.3
], [], [], [3.3, 3.3, None, 1.5, None, 1.5, 1.5, 1.5, 3.3, None, 3.3], [],
[]]
assert awkward1.to_list(listoffsetarray.rpad_and_clip(1, 0)) == [[3.3]]
assert awkward1.to_list(listoffsetarray.rpad_and_clip(1, 1)) == [[3.3],
[None],
[None],
[3.3],
[None],
[None]]
def test_typestr():
if not awkward1._util.py27:
assert str(
awkward1.type(
awkward1.to_categorical(awkward1.Array(
[1.1, 2.2, 2.2, 3.3])))) == "4 * categorical[type=float64]"
assert str(
awkward1.type(
awkward1.to_categorical(
awkward1.Array([1.1, 2.2, None, 2.2, 3.3
])))) == "5 * categorical[type=?float64]"
assert str(
awkward1.type(
awkward1.to_categorical(
awkward1.Array(["one", "two", "two", "three"
])))) == "4 * categorical[type=string]"
assert str(
awkward1.type(
awkward1.to_categorical(
awkward1.Array(
["one", "two", None, "two",
"three"])))) == "5 * categorical[type=option[string]]"
def __getitem__(self, key):
if key in self._dict:
return self._dict[key]
elif key in self._tree:
self._materialized.add(key)
array = self._tree[key].array(**self._branchargs)
if self._flatten and isinstance(
awkward1.type(array).type, awkward1.types.ListType):
array = awkward1.flatten(array)
array = awkward1.to_awkward0(array)
self._dict[key] = array
return self._dict[key]
else:
raise KeyError(key)
def test_type():
content1 = awkward1.layout.NumpyArray(
numpy.array([1, 2, 3, 4, 5], dtype=numpy.int64))
content2 = awkward1.layout.NumpyArray(
numpy.array([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9],
dtype=numpy.float64))
offsets = awkward1.layout.Index64(numpy.array([0, 3, 3, 5, 6, 9]))
listoffsetarray = awkward1.layout.ListOffsetArray64(offsets, content2)
recordarray = awkward1.layout.RecordArray([content1, listoffsetarray])
assert str(awkward1.type(recordarray)) == '(int64, var * float64)'
assert awkward1.type(recordarray) == awkward1.types.RecordType(
(awkward1.types.PrimitiveType("int64"),
awkward1.types.ListType(awkward1.types.PrimitiveType("float64"))))
assert awkward1.type(recordarray[2]) == awkward1.types.RecordType(
(awkward1.types.PrimitiveType("int64"),
awkward1.types.ListType(awkward1.types.PrimitiveType("float64"))))
recordarray = awkward1.layout.RecordArray([content1, listoffsetarray],
keys=["one", "two"])
assert str(
awkward1.type(recordarray)) in ('{"one": int64, "two": var * float64}',
'{"two": var * float64, "one": int64}')
assert str(
awkward1.types.RecordType(
(awkward1.types.PrimitiveType("int32"),
awkward1.types.PrimitiveType("float64")))) == '(int32, float64)'
assert str(
awkward1.types.RecordType({
"one":
awkward1.types.PrimitiveType("int32"),
"two":
awkward1.types.PrimitiveType("float64")
})) in ('{"one": int32, "two": float64}',
'{"two": float64, "one": int32}')
assert awkward1.type(recordarray) == awkward1.types.RecordType({
"one":
awkward1.types.PrimitiveType("int64"),
"two":
awkward1.types.ListType(awkward1.types.PrimitiveType("float64"))
})
assert awkward1.type(recordarray[2]) == awkward1.types.RecordType({
"one":
awkward1.types.PrimitiveType("int64"),
"two":
awkward1.types.ListType(awkward1.types.PrimitiveType("float64"))
})
def test_type():
assert str(awkward1.type(regulararray)) == "2 * var * float64"
def test_keepdims_none1():
content = awkward1.Array([0, 1, 2, None, 4, 5, None, None, 8, 9, 10, 11, 12, None, 14, 15, 16, 17, 18, None, None, None, None, None, None, 25, 26, 27, 28, 29]).layout
regular = awkward1.layout.RegularArray(content, 5)
listoffset = regular.toListOffsetArray64(False)
regular_regular = awkward1.layout.RegularArray(regular, 3)
listoffset_regular = regular_regular.toListOffsetArray64(False)
regular_listoffset = awkward1.layout.RegularArray(listoffset, 3)
listoffset_listoffset = regular_listoffset.toListOffsetArray64(False)
assert str(awkward1.type(awkward1.Array(listoffset_listoffset))) == "2 * var * var * ?int64"
axis1 = awkward1.sum(listoffset_listoffset, axis=-1, keepdims=True)
axis2 = awkward1.sum(listoffset_listoffset, axis=-2, keepdims=True)
axis3 = awkward1.sum(listoffset_listoffset, axis=-3, keepdims=True)
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * var * var * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * var * var * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "1 * var * var * int64"
assert str(awkward1.type(awkward1.Array(listoffset_regular))) == "2 * var * 5 * ?int64"
axis1 = awkward1.sum(listoffset_regular, axis=-1, keepdims=True)
axis2 = awkward1.sum(listoffset_regular, axis=-2, keepdims=True)
axis3 = awkward1.sum(listoffset_regular, axis=-3, keepdims=True)
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * var * var * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * var * var * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "1 * var * var * int64"
assert str(awkward1.type(awkward1.Array(regular_listoffset))) == "2 * 3 * var * ?int64"
axis1 = awkward1.sum(regular_listoffset, axis=-1, keepdims=True)
axis2 = awkward1.sum(regular_listoffset, axis=-2, keepdims=True)
axis3 = awkward1.sum(regular_listoffset, axis=-3, keepdims=True)
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * 3 * var * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * 1 * var * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "1 * 3 * var * int64"
assert str(awkward1.type(awkward1.Array(regular_regular))) == "2 * 3 * 5 * ?int64"
axis1 = awkward1.sum(regular_regular, axis=-1, keepdims=True)
axis2 = awkward1.sum(regular_regular, axis=-2, keepdims=True)
axis3 = awkward1.sum(regular_regular, axis=-3, keepdims=True)
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * 3 * var * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * 1 * var * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "1 * 3 * var * int64"
def test_nokeepdims():
nparray = numpy.arange(2*3*5, dtype=numpy.int64).reshape(2, 3, 5)
content = awkward1.layout.NumpyArray(numpy.arange(2*3*5, dtype=numpy.int64))
regular = awkward1.layout.RegularArray(content, 5)
listoffset = regular.toListOffsetArray64(False)
regular_regular = awkward1.layout.RegularArray(regular, 3)
listoffset_regular = regular_regular.toListOffsetArray64(False)
regular_listoffset = awkward1.layout.RegularArray(listoffset, 3)
listoffset_listoffset = regular_listoffset.toListOffsetArray64(False)
assert awkward1.to_list(regular_regular) == [[[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]], [[15, 16, 17, 18, 19], [20, 21, 22, 23, 24], [25, 26, 27, 28, 29]]]
assert awkward1.to_list(listoffset_regular) == [[[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]], [[15, 16, 17, 18, 19], [20, 21, 22, 23, 24], [25, 26, 27, 28, 29]]]
assert awkward1.to_list(regular_listoffset) == [[[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]], [[15, 16, 17, 18, 19], [20, 21, 22, 23, 24], [25, 26, 27, 28, 29]]]
assert awkward1.to_list(listoffset_listoffset) == [[[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]], [[15, 16, 17, 18, 19], [20, 21, 22, 23, 24], [25, 26, 27, 28, 29]]]
assert str(awkward1.type(awkward1.Array(listoffset_listoffset))) == "2 * var * var * int64"
axis1 = awkward1.sum(listoffset_listoffset, axis=-1)
axis2 = awkward1.sum(listoffset_listoffset, axis=-2)
axis3 = awkward1.sum(listoffset_listoffset, axis=-3)
assert awkward1.to_list(axis1) == numpy.sum(nparray, axis=-1).tolist()
assert awkward1.to_list(axis2) == numpy.sum(nparray, axis=-2).tolist()
assert awkward1.to_list(axis3) == numpy.sum(nparray, axis=-3).tolist()
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * var * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * var * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "3 * var * int64"
assert str(awkward1.type(awkward1.Array(listoffset_regular))) == "2 * var * 5 * int64"
axis1 = awkward1.sum(listoffset_regular, axis=-1)
axis2 = awkward1.sum(listoffset_regular, axis=-2)
axis3 = awkward1.sum(listoffset_regular, axis=-3)
assert awkward1.to_list(axis1) == numpy.sum(nparray, axis=-1).tolist()
assert awkward1.to_list(axis2) == numpy.sum(nparray, axis=-2).tolist()
assert awkward1.to_list(axis3) == numpy.sum(nparray, axis=-3).tolist()
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * var * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * 5 * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "3 * 5 * int64"
assert str(awkward1.type(awkward1.Array(regular_listoffset))) == "2 * 3 * var * int64"
axis1 = awkward1.sum(regular_listoffset, axis=-1)
axis2 = awkward1.sum(regular_listoffset, axis=-2)
axis3 = awkward1.sum(regular_listoffset, axis=-3)
assert awkward1.to_list(axis1) == numpy.sum(nparray, axis=-1).tolist()
assert awkward1.to_list(axis2) == numpy.sum(nparray, axis=-2).tolist()
assert awkward1.to_list(axis3) == numpy.sum(nparray, axis=-3).tolist()
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * 3 * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * var * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "3 * var * int64"
assert str(awkward1.type(awkward1.Array(regular_regular))) == "2 * 3 * 5 * int64"
axis1 = awkward1.sum(regular_regular, axis=-1)
axis2 = awkward1.sum(regular_regular, axis=-2)
axis3 = awkward1.sum(regular_regular, axis=-3)
assert awkward1.to_list(axis1) == numpy.sum(nparray, axis=-1).tolist()
assert awkward1.to_list(axis2) == numpy.sum(nparray, axis=-2).tolist()
assert awkward1.to_list(axis3) == numpy.sum(nparray, axis=-3).tolist()
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * 3 * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * 5 * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "3 * 5 * int64"
def test_unknown():
a = awkward1.from_json("[[], [], []]", highlevel=False)
assert awkward1.to_list(a) == [[], [], []]
assert str(awkward1.type(a)) == "var * unknown"
assert awkward1.type(a) == awkward1.types.ListType(
awkward1.types.UnknownType())
assert not awkward1.type(a) == awkward1.types.PrimitiveType("float64")
a = awkward1.from_json("[[], [[], []], [[], [], []]]", highlevel=False)
assert awkward1.to_list(a) == [[], [[], []], [[], [], []]]
assert str(awkward1.type(a)) == "var * var * unknown"
assert awkward1.type(a) == awkward1.types.ListType(
awkward1.types.ListType(awkward1.types.UnknownType()))
a = awkward1.layout.ArrayBuilder()
a.beginlist()
a.endlist()
a.beginlist()
a.endlist()
a.beginlist()
a.endlist()
assert awkward1.to_list(a) == [[], [], []]
assert str(awkward1.type(a)) == "var * unknown"
assert awkward1.type(a) == awkward1.types.ListType(
awkward1.types.UnknownType())
assert not awkward1.type(a) == awkward1.types.PrimitiveType("float64")
a = a.snapshot()
assert awkward1.to_list(a) == [[], [], []]
assert str(awkward1.type(a)) == "var * unknown"
assert awkward1.type(a) == awkward1.types.ListType(
awkward1.types.UnknownType())
assert not awkward1.type(a) == awkward1.types.PrimitiveType("float64")
def test_nokeepdims_mask1():
mask = awkward1.layout.Index8(numpy.array([False, False, False, True, False, False, True, True, False, False, False, False, False, True, False, False, False, False, False, True, True, True, True, True, True, False, False, False, False, False]))
content = awkward1.layout.ByteMaskedArray(mask, awkward1.layout.NumpyArray(numpy.arange(2*3*5, dtype=numpy.int64)), valid_when=False)
regular = awkward1.layout.RegularArray(content, 5)
listoffset = regular.toListOffsetArray64(False)
regular_regular = awkward1.layout.RegularArray(regular, 3)
listoffset_regular = regular_regular.toListOffsetArray64(False)
regular_listoffset = awkward1.layout.RegularArray(listoffset, 3)
listoffset_listoffset = regular_listoffset.toListOffsetArray64(False)
assert str(awkward1.type(awkward1.Array(listoffset_listoffset))) == "2 * var * var * ?int64"
axis1 = awkward1.sum(listoffset_listoffset, axis=-1)
axis2 = awkward1.sum(listoffset_listoffset, axis=-2)
axis3 = awkward1.sum(listoffset_listoffset, axis=-3)
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * var * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * var * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "3 * var * int64"
assert str(awkward1.type(awkward1.Array(listoffset_regular))) == "2 * var * 5 * ?int64"
axis1 = awkward1.sum(listoffset_regular, axis=-1)
axis2 = awkward1.sum(listoffset_regular, axis=-2)
axis3 = awkward1.sum(listoffset_regular, axis=-3)
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * var * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * var * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "3 * var * int64"
assert str(awkward1.type(awkward1.Array(regular_listoffset))) == "2 * 3 * var * ?int64"
axis1 = awkward1.sum(regular_listoffset, axis=-1)
axis2 = awkward1.sum(regular_listoffset, axis=-2)
axis3 = awkward1.sum(regular_listoffset, axis=-3)
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * 3 * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * var * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "3 * var * int64"
assert str(awkward1.type(awkward1.Array(regular_regular))) == "2 * 3 * 5 * ?int64"
axis1 = awkward1.sum(regular_regular, axis=-1)
axis2 = awkward1.sum(regular_regular, axis=-2)
axis3 = awkward1.sum(regular_regular, axis=-3)
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * 3 * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * var * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "3 * var * int64"
def test_UnmaskedArray():
content_float64 = awkward1.layout.NumpyArray(numpy.array([0.25, 0.5, 3.5, 4.5, 5.5], dtype=numpy.float64))
array_float64 = awkward1.layout.UnmaskedArray(content_float64)
assert awkward1.to_list(array_float64) == [0.25, 0.5, 3.5, 4.5, 5.5]
assert str(awkward1.type(content_float64)) == "float64"
assert str(awkward1.type(awkward1.Array(content_float64))) == "5 * float64"
assert str(awkward1.type(array_float64)) == "?float64"
assert str(awkward1.type(awkward1.Array(array_float64))) == "5 * ?float64"
assert numpy.can_cast(numpy.float32, numpy.float64) == True
assert numpy.can_cast(numpy.float64, numpy.float32, 'unsafe') == True
assert numpy.can_cast(numpy.float64, numpy.int8, 'unsafe') == True
content_float32 = awkward1.values_astype(content_float64, 'float32', highlevel=False)
array_float32 = awkward1.layout.UnmaskedArray(content_float32)
assert awkward1.to_list(array_float32) == [0.25, 0.5, 3.5, 4.5, 5.5]
assert str(awkward1.type(content_float32)) == "float32"
assert str(awkward1.type(awkward1.Array(content_float32))) == "5 * float32"
assert str(awkward1.type(array_float32)) == "?float32"
assert str(awkward1.type(awkward1.Array(array_float32))) == "5 * ?float32"
content_int8 = awkward1.values_astype(content_float64, 'int8', highlevel=False)
array_int8 = awkward1.layout.UnmaskedArray(content_int8)
assert awkward1.to_list(array_int8) == [0, 0, 3, 4, 5]
assert str(awkward1.type(content_int8)) == "int8"
assert str(awkward1.type(awkward1.Array(content_int8))) == "5 * int8"
assert str(awkward1.type(array_int8)) == "?int8"
assert str(awkward1.type(awkward1.Array(array_int8))) == "5 * ?int8"
content_from_int8 = awkward1.values_astype(content_int8, 'float64', highlevel=False)
array_from_int8 = awkward1.layout.UnmaskedArray(content_from_int8)
assert awkward1.to_list(array_from_int8) == [0, 0, 3, 4, 5]
assert str(awkward1.type(content_from_int8)) == "float64"
assert str(awkward1.type(awkward1.Array(content_from_int8))) == "5 * float64"
assert str(awkward1.type(array_from_int8)) == "?float64"
assert str(awkward1.type(awkward1.Array(array_from_int8))) == "5 * ?float64"
def test_keepdims_mask3():
content = awkward1.layout.NumpyArray(numpy.arange(2*3*5, dtype=numpy.int64))
regular = awkward1.layout.RegularArray(content, 5)
listoffset = regular.toListOffsetArray64(False)
regular_regular = awkward1.layout.RegularArray(regular, 3)
listoffset_regular = regular_regular.toListOffsetArray64(False)
regular_listoffset = awkward1.layout.RegularArray(listoffset, 3)
listoffset_listoffset = regular_listoffset.toListOffsetArray64(False)
mask = awkward1.layout.Index8(numpy.array([True, False]))
regular_regular = awkward1.layout.ByteMaskedArray(mask, regular_regular, valid_when=False)
listoffset_regular = awkward1.layout.ByteMaskedArray(mask, listoffset_regular, valid_when=False)
regular_listoffset = awkward1.layout.ByteMaskedArray(mask, regular_listoffset, valid_when=False)
listoffset_listoffset = awkward1.layout.ByteMaskedArray(mask, listoffset_listoffset, valid_when=False)
assert str(awkward1.type(awkward1.Array(listoffset_listoffset))) == "2 * option[var * var * int64]"
axis1 = awkward1.sum(listoffset_listoffset, axis=-1, keepdims=True)
axis2 = awkward1.sum(listoffset_listoffset, axis=-2, keepdims=True)
axis3 = awkward1.sum(listoffset_listoffset, axis=-3, keepdims=True)
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * option[var * var * int64]"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * option[var * var * int64]"
assert str(awkward1.type(awkward1.Array(axis3))) == "1 * var * var * int64"
assert str(awkward1.type(awkward1.Array(listoffset_regular))) == "2 * option[var * 5 * int64]"
axis1 = awkward1.sum(listoffset_regular, axis=-1, keepdims=True)
axis2 = awkward1.sum(listoffset_regular, axis=-2, keepdims=True)
axis3 = awkward1.sum(listoffset_regular, axis=-3, keepdims=True)
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * option[var * 1 * int64]"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * option[var * 5 * int64]"
assert str(awkward1.type(awkward1.Array(axis3))) == "1 * var * 5 * int64"
assert str(awkward1.type(awkward1.Array(regular_listoffset))) == "2 * option[3 * var * int64]"
axis1 = awkward1.sum(regular_listoffset, axis=-1, keepdims=True)
axis2 = awkward1.sum(regular_listoffset, axis=-2, keepdims=True)
axis3 = awkward1.sum(regular_listoffset, axis=-3, keepdims=True)
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * option[var * var * int64]"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * option[var * var * int64]"
assert str(awkward1.type(awkward1.Array(axis3))) == "1 * var * var * int64"
assert str(awkward1.type(awkward1.Array(regular_regular))) == "2 * option[3 * 5 * int64]"
axis1 = awkward1.sum(regular_regular, axis=-1, keepdims=True)
axis2 = awkward1.sum(regular_regular, axis=-2, keepdims=True)
axis3 = awkward1.sum(regular_regular, axis=-3, keepdims=True)
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * option[var * 1 * int64]"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * option[var * 5 * int64]"
assert str(awkward1.type(awkward1.Array(axis3))) == "1 * var * 5 * int64"
def test_fromiter():
array = awkward1.Array([numpy.array([1, 2, 3]), numpy.array([4, 5, 6, 7])])
assert str(awkward1.type(array)) == "2 * var * int64"
assert awkward1.to_list(array) == [[1, 2, 3], [4, 5, 6, 7]]
def test_keepdims():
nparray = numpy.arange(2*3*5, dtype=numpy.int64).reshape(2, 3, 5)
content = awkward1.layout.NumpyArray(numpy.arange(2*3*5, dtype=numpy.int64))
regular = awkward1.layout.RegularArray(content, 5)
listoffset = regular.toListOffsetArray64(False)
regular_regular = awkward1.layout.RegularArray(regular, 3)
listoffset_regular = regular_regular.toListOffsetArray64(False)
regular_listoffset = awkward1.layout.RegularArray(listoffset, 3)
listoffset_listoffset = regular_listoffset.toListOffsetArray64(False)
assert str(awkward1.type(awkward1.Array(listoffset_listoffset))) == "2 * var * var * int64"
axis1 = awkward1.sum(listoffset_listoffset, axis=-1, keepdims=True)
axis2 = awkward1.sum(listoffset_listoffset, axis=-2, keepdims=True)
axis3 = awkward1.sum(listoffset_listoffset, axis=-3, keepdims=True)
assert awkward1.to_list(axis1) == numpy.sum(nparray, axis=-1, keepdims=True).tolist()
assert awkward1.to_list(axis2) == numpy.sum(nparray, axis=-2, keepdims=True).tolist()
assert awkward1.to_list(axis3) == numpy.sum(nparray, axis=-3, keepdims=True).tolist()
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * var * var * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * var * var * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "1 * var * var * int64"
assert str(awkward1.type(awkward1.Array(listoffset_regular))) == "2 * var * 5 * int64"
axis1 = awkward1.sum(listoffset_regular, axis=-1, keepdims=True)
axis2 = awkward1.sum(listoffset_regular, axis=-2, keepdims=True)
axis3 = awkward1.sum(listoffset_regular, axis=-3, keepdims=True)
assert awkward1.to_list(axis1) == numpy.sum(nparray, axis=-1, keepdims=True).tolist()
assert awkward1.to_list(axis2) == numpy.sum(nparray, axis=-2, keepdims=True).tolist()
assert awkward1.to_list(axis3) == numpy.sum(nparray, axis=-3, keepdims=True).tolist()
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * var * 1 * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * var * 5 * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "1 * var * 5 * int64"
assert str(awkward1.type(awkward1.Array(regular_listoffset))) == "2 * 3 * var * int64"
axis1 = awkward1.sum(regular_listoffset, axis=-1, keepdims=True)
axis2 = awkward1.sum(regular_listoffset, axis=-2, keepdims=True)
axis3 = awkward1.sum(regular_listoffset, axis=-3, keepdims=True)
assert awkward1.to_list(axis1) == numpy.sum(nparray, axis=-1, keepdims=True).tolist()
assert awkward1.to_list(axis2) == numpy.sum(nparray, axis=-2, keepdims=True).tolist()
assert awkward1.to_list(axis3) == numpy.sum(nparray, axis=-3, keepdims=True).tolist()
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * 3 * var * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * 1 * var * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "1 * 3 * var * int64"
assert str(awkward1.type(awkward1.Array(regular_regular))) == "2 * 3 * 5 * int64"
axis1 = awkward1.sum(regular_regular, axis=-1, keepdims=True)
axis2 = awkward1.sum(regular_regular, axis=-2, keepdims=True)
axis3 = awkward1.sum(regular_regular, axis=-3, keepdims=True)
assert awkward1.to_list(axis1) == numpy.sum(nparray, axis=-1, keepdims=True).tolist()
assert awkward1.to_list(axis2) == numpy.sum(nparray, axis=-2, keepdims=True).tolist()
assert awkward1.to_list(axis3) == numpy.sum(nparray, axis=-3, keepdims=True).tolist()
assert str(awkward1.type(awkward1.Array(axis1))) == "2 * 3 * 1 * int64"
assert str(awkward1.type(awkward1.Array(axis2))) == "2 * 1 * 5 * int64"
assert str(awkward1.type(awkward1.Array(axis3))) == "1 * 3 * 5 * int64"
def test_builder_string():
builder = awkward1.ArrayBuilder()
builder.bytestring(b"one")
builder.bytestring(b"two")
builder.bytestring(b"three")
a = builder.snapshot()
if py27:
assert str(a) == "['one', 'two', 'three']"
else:
assert str(a) == "[b'one', b'two', b'three']"
assert awkward1.to_list(a) == [b'one', b'two', b'three']
assert awkward1.to_json(a) == '["one","two","three"]'
if py27:
assert repr(a) == "<Array ['one', 'two', 'three'] type='3 * bytes'>"
else:
assert repr(a) == "<Array [b'one', b'two', b'three'] type='3 * bytes'>"
assert repr(awkward1.type(a)) == "3 * bytes"
builder = awkward1.ArrayBuilder()
builder.string("one")
builder.string("two")
builder.string("three")
a = builder.snapshot()
if py27:
assert str(a) == "[u'one', u'two', u'three']"
else:
assert str(a) == "['one', 'two', 'three']"
assert awkward1.to_list(a) == ['one', 'two', 'three']
assert awkward1.to_json(a) == '["one","two","three"]'
if py27:
assert repr(
a) == "<Array [u'one', u'two', u'three'] type='3 * string'>"
else:
assert repr(a) == "<Array ['one', 'two', 'three'] type='3 * string'>"
assert repr(awkward1.type(a)) == "3 * string"
builder = awkward1.ArrayBuilder()
builder.begin_list()
builder.string("one")
builder.string("two")
builder.string("three")
builder.end_list()
builder.begin_list()
builder.end_list()
builder.begin_list()
builder.string("four")
builder.string("five")
builder.end_list()
a = builder.snapshot()
if py27:
assert str(a) == "[[u'one', u'two', u'three'], [], [u'four', u'five']]"
else:
assert str(a) == "[['one', 'two', 'three'], [], ['four', 'five']]"
assert awkward1.to_list(a) == [['one', 'two', 'three'], [],
['four', 'five']]
assert awkward1.to_json(a) == '[["one","two","three"],[],["four","five"]]'
assert repr(awkward1.type(a)) == "3 * var * string"
def test_0459_types():
plain_plain = awkward1.Array([0.0, 1.1, 2.2, 3.3, 4.4])
array_plain = awkward1.with_parameter(plain_plain, "__array__", "zoinks")
plain_isdoc = awkward1.with_parameter(plain_plain, "__doc__", "This is a zoink.")
array_isdoc = awkward1.with_parameter(array_plain, "__doc__", "This is a zoink.")
assert awkward1.parameters(plain_plain) == {}
assert awkward1.parameters(array_plain) == {"__array__": "zoinks"}
assert awkward1.parameters(plain_isdoc) == {"__doc__": "This is a zoink."}
assert awkward1.parameters(array_isdoc) == {"__array__": "zoinks", "__doc__": "This is a zoink."}
assert awkward1.type(plain_plain) == awkward1.type(plain_plain)
assert awkward1.type(array_plain) == awkward1.type(array_plain)
assert awkward1.type(plain_isdoc) == awkward1.type(plain_isdoc)
assert awkward1.type(array_isdoc) == awkward1.type(array_isdoc)
assert awkward1.type(plain_plain) != awkward1.type(array_plain)
assert awkward1.type(array_plain) != awkward1.type(plain_plain)
assert awkward1.type(plain_plain) == awkward1.type(plain_isdoc)
assert awkward1.type(plain_isdoc) == awkward1.type(plain_plain)
assert awkward1.type(array_plain) == awkward1.type(array_isdoc)
assert awkward1.type(array_isdoc) == awkward1.type(array_plain)
assert awkward1.type(plain_isdoc) != awkward1.type(array_isdoc)
assert awkward1.type(array_isdoc) != awkward1.type(plain_isdoc)
def test_simple_type():
assert str(awkward1.type(content)) == "float64"
def _check_lorentz_vector(data):
if '__record__' in awkward1.type(data).type.parameters and \
awkward1.type(data).type.parameters['__record__'] == "TLorentzVector":
return data.fE
return data
