def test_record():
array1 = awkward1.from_iter([{
"x": 1,
"y": 1.1
}, {
"x": 2,
"y": 2.2
}, {
"x": 3,
"y": 3.3
}],
highlevel=False)
assert awkward1.to_list(array1) == [{
"x": 1,
"y": 1.1
}, {
"x": 2,
"y": 2.2
}, {
"x": 3,
"y": 3.3
}]
array2 = array1.setitem_field(
"z", awkward1.from_iter([[], [1], [2, 2]], highlevel=False))
assert awkward1.to_list(array2) == [{
"x": 1,
"y": 1.1,
"z": []
}, {
"x": 2,
"y": 2.2,
"z": [1]
}, {
"x": 3,
"y": 3.3,
"z": [2, 2]
}]
array3 = array1.setitem_field(
None, awkward1.from_iter([[], [1], [2, 2]], highlevel=False))
assert awkward1.to_list(array3) == [{
"x": 1,
"y": 1.1,
"2": []
}, {
"x": 2,
"y": 2.2,
"2": [1]
}, {
"x": 3,
"y": 3.3,
"2": [2, 2]
}]
array3 = array1.setitem_field(
0, awkward1.from_iter([[], [1], [2, 2]], highlevel=False))
assert awkward1.to_list(array3) == [{
"x": 1,
"y": 1.1,
"0": []
}, {
"x": 2,
"y": 2.2,
"0": [1]
}, {
"x": 3,
"y": 3.3,
"0": [2, 2]
}]
array1 = awkward1.from_iter([(1, 1.1), (2, 2.2), (3, 3.3)],
highlevel=False)
assert awkward1.to_list(array1) == [(1, 1.1), (2, 2.2), (3, 3.3)]
array2 = array1.setitem_field(
"z", awkward1.from_iter([[], [1], [2, 2]], highlevel=False))
assert awkward1.to_list(array2) == [{
"0": 1,
"1": 1.1,
"z": []
}, {
"0": 2,
"1": 2.2,
"z": [1]
}, {
"0": 3,
"1": 3.3,
"z": [2, 2]
}]
array3 = array1.setitem_field(
None, awkward1.from_iter([[], [1], [2, 2]], highlevel=False))
assert awkward1.to_list(array3) == [(1, 1.1, []), (2, 2.2, [1]),
(3, 3.3, [2, 2])]
array3 = array1.setitem_field(
0, awkward1.from_iter([[], [1], [2, 2]], highlevel=False))
assert awkward1.to_list(array3) == [([], 1, 1.1), ([1], 2, 2.2),
([2, 2], 3, 3.3)]
array3 = array1.setitem_field(
1, awkward1.from_iter([[], [1], [2, 2]], highlevel=False))
assert awkward1.to_list(array3) == [(1, [], 1.1), (2, [1], 2.2),
(3, [2, 2], 3.3)]
array3 = array1.setitem_field(
100, awkward1.from_iter([[], [1], [2, 2]], highlevel=False))
assert awkward1.to_list(array3) == [(1, 1.1, []), (2, 2.2, [1]),
(3, 3.3, [2, 2])]
def test_fromiter():
assert awkward1.to_list(awkward1.from_iter([True, True, False, False, True])) == [True, True, False, False, True]
assert awkward1.to_list(awkward1.from_iter([5, 4, 3, 2, 1])) == [5, 4, 3, 2, 1]
assert awkward1.to_list(awkward1.from_iter([5, 4, 3.14, 2.22, 1.23])) == [5.0, 4.0, 3.14, 2.22, 1.23]
assert awkward1.to_list(awkward1.from_iter([[1.1, 2.2, 3.3], [], [4.4, 5.5]])) == [[1.1, 2.2, 3.3], [], [4.4, 5.5]]
assert awkward1.to_list(awkward1.from_iter([[[1.1, 2.2, 3.3], []], [[4.4, 5.5]], [], [[6.6], [7.7, 8.8, 9.9]]])) == [[[1.1, 2.2, 3.3], []], [[4.4, 5.5]], [], [[6.6], [7.7, 8.8, 9.9]]]
def test_fromiter():
dataset = [
[(1, 1.1), (2, 2.2), (3, 3.3)],
[(1, [1.1, 2.2, 3.3]), (2, []), (3, [4.4, 5.5])],
[[(1, 1.1), (2, 2.2), (3, 3.3)], [], [(4, 4.4), (5, 5.5)]],
[((1, 1), 1.1), ((2, 2), 2.2), ((3, 3), 3.3)],
[({
"x": 1,
"y": 1
}, 1.1), ({
"x": 2,
"y": 2
}, 2.2), ({
"x": 3,
"y": 3
}, 3.3)],
[{
"one": 1,
"two": 1.1
}, {
"one": 2,
"two": 2.2
}, {
"one": 3,
"two": 3.3
}],
[{
"one": 1,
"two": [1.1, 2.2, 3.3]
}, {
"one": 2,
"two": []
}, {
"one": 3,
"two": [4.4, 5.5]
}],
[[{
"one": 1,
"two": 1.1
}, {
"one": 2,
"two": 2.2
}, {
"one": 3,
"two": 3.3
}], [], [{
"one": 4,
"two": 4.4
}, {
"one": 5,
"two": 5.5
}]],
[{
"one": {
"x": 1,
"y": 1
},
"two": 1.1
}, {
"one": {
"x": 2,
"y": 2
},
"two": 2.2
}, {
"one": {
"x": 3,
"y": 3
},
"two": 3.3
}],
[{
"one": (1, 1),
"two": 1.1
}, {
"one": (2, 2),
"two": 2.2
}, {
"one": (3, 3),
"two": 3.3
}],
]
for datum in dataset:
assert awkward1.to_list(awkward1.from_iter(datum)) == datum
def test_merge_parameters():
one = awkward1.from_iter([[121, 117, 99, 107, 121], [115, 116, 117, 102, 102]], highlevel=False)
two = awkward1.from_iter(["good", "stuff"], highlevel=False)
assert awkward1.to_list(one.merge(two)) == [[121, 117, 99, 107, 121], [115, 116, 117, 102, 102], "good", "stuff"]
assert awkward1.to_list(two.merge(one)) == ["good", "stuff", [121, 117, 99, 107, 121], [115, 116, 117, 102, 102]]
def test_flatten_IndexedArray():
array = awkward1.Array([[1.1, 2.2, None, 3.3], None, [], None, [4.4, 5.5],
None])
assert awkward1.to_list(
awkward1.flatten(array)) == [1.1, 2.2, None, 3.3, 4.4, 5.5]
assert awkward1.to_list(awkward1.flatten(array[1:])) == [4.4, 5.5]
array = awkward1.Array([[[0.0, 1.1, 2.2], None, None, [3.3, 4.4]], [],
[[5.5]], [[], [6.6, 7.7, 8.8, 9.9]]])
assert awkward1.to_list(awkward1.flatten(
array, axis=2)) == [[0.0, 1.1, 2.2, 3.3, 4.4], [], [5.5],
[6.6, 7.7, 8.8, 9.9]]
assert awkward1.to_list(awkward1.flatten(array[1:],
axis=2)) == [[], [5.5],
[6.6, 7.7, 8.8, 9.9]]
assert awkward1.to_list(awkward1.flatten(array[:, 1:],
axis=2)) == [[3.3, 4.4], [], [],
[6.6, 7.7, 8.8, 9.9]]
array = awkward1.Array([[[0.0, 1.1, 2.2], [3.3, 4.4]], [], [[5.5]], None,
None, [[], [6.6, 7.7, 8.8, 9.9]]])
assert awkward1.to_list(awkward1.flatten(
array, axis=2)) == [[0.0, 1.1, 2.2, 3.3, 4.4], [], [5.5], None, None,
[6.6, 7.7, 8.8, 9.9]]
assert awkward1.to_list(awkward1.flatten(array[1:],
axis=2)) == [[], [5.5], None,
None,
[6.6, 7.7, 8.8, 9.9]]
assert awkward1.to_list(awkward1.flatten(array[:, 1:],
axis=2)) == [[3.3, 4.4], [], [],
None, None,
[6.6, 7.7, 8.8, 9.9]]
array = awkward1.Array([[[0.0, 1.1, None, 2.2], None, [], None,
[3.3, 4.4]], None, [], [[5.5]], None,
[[], [6.6, None, 7.7, 8.8, 9.9], None]])
assert awkward1.to_list(
awkward1.flatten(array)) == [[0.0, 1.1, None, 2.2], None, [], None,
[3.3, 4.4], [5.5], [],
[6.6, None, 7.7, 8.8, 9.9], None]
assert awkward1.to_list(awkward1.flatten(
array, axis=2)) == [[0.0, 1.1, None, 2.2, 3.3, 4.4], None, [], [5.5],
None, [6.6, None, 7.7, 8.8, 9.9]]
assert awkward1.to_list(awkward1.flatten(array[1:], axis=2)) == [
None, [], [5.5], None, [6.6, None, 7.7, 8.8, 9.9]
]
assert awkward1.to_list(awkward1.flatten(
array[:, 1:], axis=2)) == [[3.3, 4.4], None, [], [], None,
[6.6, None, 7.7, 8.8, 9.9]]
content = awkward1.from_iter(
[[0.0, 1.1, 2.2], [], [3.3, 4.4], [5.5], [6.6, 7.7, 8.8, 9.9]],
highlevel=False)
index = awkward1.layout.Index64(
numpy.array([2, 1, 0, 3, 3, 4], dtype=numpy.int64))
array = awkward1.Array(awkward1.layout.IndexedArray64(index, content))
assert awkward1.to_list(array) == [[3.3, 4.4], [], [0.0, 1.1, 2.2], [5.5],
[5.5], [6.6, 7.7, 8.8, 9.9]]
assert awkward1.to_list(awkward1.flatten(array)) == [
3.3, 4.4, 0.0, 1.1, 2.2, 5.5, 5.5, 6.6, 7.7, 8.8, 9.9
]
content = awkward1.from_iter([[[0.0, 1.1, 2.2], [], [3.3, 4.4]], [],
[[5.5]], [[], [6.6, 7.7, 8.8, 9.9]]],
highlevel=False)
index = awkward1.layout.Index64(
numpy.array([2, 2, 1, 0, 3], dtype=numpy.int64))
array = awkward1.Array(awkward1.layout.IndexedArray64(index, content))
assert awkward1.to_list(array) == [[[5.5]], [[5.5]], [],
[[0.0, 1.1, 2.2], [], [3.3, 4.4]],
[[], [6.6, 7.7, 8.8, 9.9]]]
assert awkward1.to_list(awkward1.flatten(
array, axis=2)) == [[5.5], [5.5], [], [0.0, 1.1, 2.2, 3.3, 4.4],
[6.6, 7.7, 8.8, 9.9]]
def test_bitmaskedarray2b():
array = awkward1.from_iter([[0.0, 1.1, 2.2], [3.3, 4.4], [5.5], [6.6, 7.7, 8.8, 9.9]], highlevel=False)
mask = awkward1.layout.IndexU8(numpy.array([66], dtype=numpy.uint8))
maskedarray = awkward1.layout.BitMaskedArray(mask, array, valid_when=False, length=4, lsb_order=True) # lsb_order is irrelevant in this example
assert awkward1.to_list(maskedarray) == [[0.0, 1.1, 2.2], None, [5.5], [6.6, 7.7, 8.8, 9.9]]
assert awkward1.to_list(maskedarray[awkward1.Array([[1, 1], None, [0], [0, -1]])]) == [[1.1, 1.1], None, [5.5], [6.6, 9.9]]
def test_getitem_basic():
one = awkward1.from_iter([[1.1, 2.2, 3.3], [], [4.4, 5.5]],
highlevel=False)
two = awkward1.from_iter([[6.6], [], [], [], [7.7, 8.8, 9.9]],
highlevel=False)
array = awkward1.partition.IrregularlyPartitionedArray([one, two])
assert awkward1.to_list(array[0]) == [1.1, 2.2, 3.3]
assert awkward1.to_list(array[1]) == []
assert awkward1.to_list(array[2]) == [4.4, 5.5]
assert awkward1.to_list(array[3]) == [6.6]
assert awkward1.to_list(array[4]) == []
assert awkward1.to_list(array[5]) == []
assert awkward1.to_list(array[6]) == []
assert awkward1.to_list(array[7]) == [7.7, 8.8, 9.9]
assert awkward1.to_list(array[-1]) == [7.7, 8.8, 9.9]
assert awkward1.to_list(array[-2]) == []
assert awkward1.to_list(array[-3]) == []
assert awkward1.to_list(array[-4]) == []
assert awkward1.to_list(array[-5]) == [6.6]
assert awkward1.to_list(array[-6]) == [4.4, 5.5]
assert awkward1.to_list(array[-7]) == []
assert awkward1.to_list(array[-8]) == [1.1, 2.2, 3.3]
assert array[:].tojson(
) == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array[2:6].tojson() == "[[4.4,5.5],[6.6],[],[]]"
assert array[1:].tojson() == "[[],[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array[2:].tojson() == "[[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array[3:].tojson() == "[[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array[4:].tojson() == "[[],[],[],[7.7,8.8,9.9]]"
assert array[5:].tojson() == "[[],[],[7.7,8.8,9.9]]"
assert array[6:].tojson() == "[[],[7.7,8.8,9.9]]"
assert array[7:].tojson() == "[[7.7,8.8,9.9]]"
assert array[8:].tojson() == "[]"
assert array[-1:].tojson() == "[[7.7,8.8,9.9]]"
assert array[-2:].tojson() == "[[],[7.7,8.8,9.9]]"
assert array[-3:].tojson() == "[[],[],[7.7,8.8,9.9]]"
assert array[-4:].tojson() == "[[],[],[],[7.7,8.8,9.9]]"
assert array[-5:].tojson() == "[[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array[-6:].tojson() == "[[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array[-7:].tojson() == "[[],[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array[-8:].tojson(
) == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array[:-1].tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[],[]]"
assert array[:-2].tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[]]"
assert array[:-3].tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[]]"
assert array[:-4].tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6]]"
assert array[:-5].tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5]]"
assert array[:-6].tojson() == "[[1.1,2.2,3.3],[]]"
assert array[:-7].tojson() == "[[1.1,2.2,3.3]]"
assert array[:-8].tojson() == "[]"
assert array[:0].tojson() == "[]"
assert array[:1].tojson() == "[[1.1,2.2,3.3]]"
assert array[:2].tojson() == "[[1.1,2.2,3.3],[]]"
assert array[:3].tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5]]"
assert array[:4].tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6]]"
assert array[:5].tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[]]"
assert array[:6].tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[]]"
assert array[:7].tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[],[]]"
assert array[:8].tojson(
) == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
one = awkward1.from_iter([{
"x": 0.0,
"y": []
}, {
"x": 1.1,
"y": [1]
}, {
"x": 2.2,
"y": [2, 2]
}],
highlevel=False)
two = awkward1.from_iter([{
"x": 3.3,
"y": [3, 3, 3]
}, {
"x": 4.4,
"y": [4, 4, 4, 4]
}],
highlevel=False)
array = awkward1.partition.IrregularlyPartitionedArray([one, two])
if not awkward1._util.py27 and not awkward1._util.py35:
assert array.tojson(
) == '[{"x":0.0,"y":[]},{"x":1.1,"y":[1]},{"x":2.2,"y":[2,2]},{"x":3.3,"y":[3,3,3]},{"x":4.4,"y":[4,4,4,4]}]'
assert array["x"].tojson() == "[0.0,1.1,2.2,3.3,4.4]"
assert array["y"].tojson() == "[[],[1],[2,2],[3,3,3],[4,4,4,4]]"
assert array[[
"x"
]].tojson() == '[{"x":0.0},{"x":1.1},{"x":2.2},{"x":3.3},{"x":4.4}]'
def test_indexedoptionarray():
layout = awkward1.from_iter([[1.1, 2.2, 3.3], None, [], [4.4, 5.5], None, None, [6.6], [7.7, 8.8, 9.9]], highlevel=False)
numbatype = awkward1._connect._numba.arrayview.tonumbatype(layout.form)
assert awkward1_connect_numba_layout.typeof(layout).name == numbatype.name
lookup1 = awkward1_connect_numba_arrayview.Lookup(layout)
lookup2 = awkward1_connect_numba_arrayview.Lookup(layout.form)
numbatype.form_fill(0, layout, lookup2)
assert numpy.array_equal(lookup1.arrayptrs, lookup2.arrayptrs)
assert numpy.array_equal(lookup1.sharedptrs == -1, lookup2.sharedptrs == -1)
counter = [0]
def materialize():
counter[0] += 1
return layout
generator = awkward1.layout.ArrayGenerator(materialize, form=layout.form, length=len(layout))
virtualarray = awkward1.layout.VirtualArray(generator)
lookup3 = awkward1_connect_numba_arrayview.Lookup(virtualarray)
assert len(lookup1.arrayptrs) + 3 == len(lookup3.arrayptrs)
array = awkward1.Array(virtualarray)
array.numba_type
assert counter[0] == 0
@numba.njit
def f3(x):
return x
assert isinstance(f3(array).layout, awkward1.layout.VirtualArray)
assert counter[0] == 0
@numba.njit
def f1(x):
return x[3][1]
assert f1(array) == 5.5
assert counter[0] == 1
assert f1(array) == 5.5
assert counter[0] == 1
@numba.njit
def f2(x, i):
return x[i]
assert awkward1.to_list(f2(array, 3)) == [4.4, 5.5]
assert counter[0] == 1
assert awkward1.to_list(f2(array, 4)) == None
assert counter[0] == 1
assert awkward1.to_list(f2(array, 3)) == [4.4, 5.5]
assert counter[0] == 1
assert awkward1.to_list(f2(array, 4)) == None
assert counter[0] == 1
assert awkward1.to_list(f3(array)) == [[1.1, 2.2, 3.3], None, [], [4.4, 5.5], None, None, [6.6], [7.7, 8.8, 9.9]]
def test_bitmaskedarray():
layout = awkward1.from_iter([[1.1, 2.2, 3.3], [999], [], [4.4, 5.5], [123, 321], [], [6.6], [7.7, 8.8, 9.9], [3, 2, 1]], highlevel=False)
layout = awkward1.layout.BitMaskedArray(awkward1.layout.IndexU8(numpy.packbits(numpy.array([False, True, False, False, True, True, False, False, False, True, True, True, True, True, True, True], dtype=numpy.bool))), layout, valid_when=False, length=9, lsb_order=False)
numbatype = awkward1._connect._numba.arrayview.tonumbatype(layout.form)
assert awkward1_connect_numba_layout.typeof(layout).name == numbatype.name
lookup1 = awkward1_connect_numba_arrayview.Lookup(layout)
lookup2 = awkward1_connect_numba_arrayview.Lookup(layout.form)
numbatype.form_fill(0, layout, lookup2)
assert numpy.array_equal(lookup1.arrayptrs, lookup2.arrayptrs)
assert numpy.array_equal(lookup1.sharedptrs == -1, lookup2.sharedptrs == -1)
counter = [0]
def materialize():
counter[0] += 1
return layout
generator = awkward1.layout.ArrayGenerator(materialize, form=layout.form, length=len(layout))
virtualarray = awkward1.layout.VirtualArray(generator)
lookup3 = awkward1_connect_numba_arrayview.Lookup(virtualarray)
assert len(lookup1.arrayptrs) + 3 == len(lookup3.arrayptrs)
array = awkward1.Array(virtualarray)
array.numba_type
assert counter[0] == 0
@numba.njit
def f3(x):
return x
assert isinstance(f3(array).layout, awkward1.layout.VirtualArray)
assert counter[0] == 0
@numba.njit
def f1(x):
return x[3][1]
assert f1(array) == 5.5
assert counter[0] == 1
assert f1(array) == 5.5
assert counter[0] == 1
@numba.njit
def f2(x, i):
return x[i]
assert awkward1.to_list(f2(array, 3)) == [4.4, 5.5]
assert counter[0] == 1
assert awkward1.to_list(f2(array, 4)) == None
assert counter[0] == 1
assert awkward1.to_list(f2(array, 3)) == [4.4, 5.5]
assert counter[0] == 1
assert awkward1.to_list(f2(array, 4)) == None
assert counter[0] == 1
assert awkward1.to_list(f3(array)) == [[1.1, 2.2, 3.3], None, [], [4.4, 5.5], None, None, [6.6], [7.7, 8.8, 9.9], [3.0, 2.0, 1.0]]
def test_0166_ByteMaskedArray():
content = awkward1.from_iter(
[[2, 3, 5], [999], [], [7, 11], [], [13], [123, 999], [17, 19]],
highlevel=False)
mask = awkward1.layout.Index8(
numpy.array([0, 1, 0, 0, 1, 0, 1, 0], dtype=numpy.int8))
array = awkward1.Array(
awkward1.layout.ByteMaskedArray(mask, content, valid_when=False))
assert awkward1.to_list(array) == [[2, 3, 5], None, [], [7, 11], None,
[13], None, [17, 19]]
assert awkward1.to_list(awkward1.prod(
array, axis=-1)) == [30, None, 1, 77, None, 13, None, 323]
content = awkward1.from_iter([[[2, 3], [5]], [[999]], [], [[7], [11]], [],
[[13]], [[123], [999]], [[17, 19]]],
highlevel=False)
mask = awkward1.layout.Index8(
numpy.array([0, 1, 0, 0, 1, 0, 1, 0], dtype=numpy.int8))
array = awkward1.Array(
awkward1.layout.ByteMaskedArray(mask, content, valid_when=False))
assert awkward1.to_list(array) == [[[2, 3], [5]], None, [], [[7], [11]],
None, [[13]], None, [[17, 19]]]
assert awkward1.to_list(awkward1.prod(array, axis=-1)) == [[6,
5], None, [],
[7, 11], None,
[13], None,
[323]]
content = awkward1.from_iter(
[[2, 3], [999], [5], [7], [11], [13], [], [17], [19]], highlevel=False)
mask = awkward1.layout.Index8(
numpy.array([0, 1, 0, 0, 0, 0, 1, 0, 0], dtype=numpy.int8))
bytemasked = awkward1.layout.ByteMaskedArray(mask,
content,
valid_when=False)
offsets = awkward1.layout.Index64(
numpy.array([0, 3, 3, 5, 6, 9], dtype=numpy.int64))
array = awkward1.Array(
awkward1.layout.ListOffsetArray64(offsets, bytemasked))
array = awkward1.Array([[[2, 3], None, [5]], [], [[7], [11]], [[13]],
[None, [17], [19]]])
assert awkward1.to_list(awkward1.prod(array, axis=-1)) == [[6,
None, 5], [],
[7, 11], [13],
[None, 17, 19]]
content = awkward1.from_iter([6, None, 5, 7, 11, 13, None, 17, 19],
highlevel=False)
mask = awkward1.layout.Index8(
numpy.array([0, 1, 0, 0, 0, 0, 1, 0, 0], dtype=numpy.int8))
bytemasked = awkward1.layout.ByteMaskedArray(mask,
content,
valid_when=False)
offsets = awkward1.layout.Index64(
numpy.array([0, 3, 3, 5, 6, 9], dtype=numpy.int64))
array = awkward1.Array(
awkward1.layout.ListOffsetArray64(offsets, bytemasked))
assert awkward1.to_list(array) == [[6, None, 5], [], [7, 11], [13],
[None, 17, 19]]
assert awkward1.to_list(awkward1.prod(array,
axis=-1)) == [30, 1, 77, 13, 323]
[1, 2, 3])
with pytest.raises(NotImplementedError, match="cannot determine binning"):
plot._get_binning({})
@mock.patch("simplify.helpers.plotting.data_MC")
@mock.patch("simplify.plot._get_binning", return_value=np.asarray([1, 2]))
@mock.patch(
"simplify.configuration.get_region_dict",
return_value={
"Name": "region",
"Variable": "x"
},
)
@mock.patch("simplify.model_tools.calculate_stdev",
return_value=ak.from_iter([[0.3]]))
@mock.patch(
"simplify.model_tools.get_prefit_uncertainties",
return_value=(ak.from_iter([0.04956657, 0.0])),
)
@mock.patch(
"simplify.model_tools.get_asimov_parameters",
return_value=([1.0, 1.0]),
)
def test_data_MC(mock_asimov, mock_unc, mock_stdev, mock_dict, mock_bins,
mock_draw, example_spec):
config = {}
figure_folder = "tmp"
model_spec = pyhf.Workspace(example_spec).model().spec
plot.data_MC(config, example_spec, figure_folder=figure_folder)
def test_missing():
array = awkward1.from_iter([[[2.2, 1.1, 3.3]], [[]], [None, None, None], [[-4.4, -5.5, -6.6]]], highlevel=False)
assert awkward1.to_list(array.argmin(axis=2)) == [[1], [None], [None, None, None], [2]]
def test_ByteMaskedArray_pad_none():
content = awkward1.from_iter(
[[[0.0, 1.1, 2.2], [], [3.3, 4.4]], [], [[5.5]],
[[6.6, 7.7, 8.8, 9.9]], [[], [10.0, 11.1, 12.2]]],
highlevel=False)
mask = awkward1.layout.Index8(
numpy.array([0, 0, 1, 1, 0], dtype=numpy.int8))
array = awkward1.Array(
awkward1.layout.ByteMaskedArray(mask, content, valid_when=False))
assert awkward1.to_list(array) == [[[0.0, 1.1, 2.2], [], [3.3, 4.4]], [],
None, None, [[], [10.0, 11.1, 12.2]]]
assert awkward1.to_list(awkward1.pad_none(array, 7,
axis=0)) == [[[0.0, 1.1,
2.2], [],
[3.3, 4.4]], [],
None, None,
[[],
[10.0, 11.1,
12.2]], None,
None]
assert awkward1.to_list(
awkward1.pad_none(array, 7, axis=-3)) == [[[0.0, 1.1, 2.2], [],
[3.3, 4.4]], [], None, None,
[[], [10.0, 11.1, 12.2]],
None, None]
assert awkward1.to_list(awkward1.pad_none(array, 3,
axis=1)) == [[[0.0, 1.1, 2.2],
[], [3.3, 4.4]],
[None, None, None],
None, None,
[[],
[10.0, 11.1, 12.2],
None]]
assert awkward1.to_list(awkward1.pad_none(
array, 3, axis=-2)) == [[[0.0, 1.1, 2.2], [], [3.3, 4.4]],
[None, None, None], None, None,
[[], [10.0, 11.1, 12.2], None]]
assert awkward1.to_list(awkward1.pad_none(array, 3,
axis=2)) == [[[0.0, 1.1, 2.2],
[None, None, None],
[3.3, 4.4, None]],
[], None, None,
[[None, None, None],
[10.0, 11.1,
12.2]]]
assert awkward1.to_list(awkward1.pad_none(
array, 3, axis=-1)) == [[[0.0, 1.1, 2.2], [None, None, None],
[3.3, 4.4, None]], [], None, None,
[[None, None, None], [10.0, 11.1, 12.2]]]
assert awkward1.to_list(awkward1.pad_none(array, 3, axis=0,
clip=True)) == [[[0.0, 1.1, 2.2],
[], [3.3, 4.4]],
[], None]
assert awkward1.to_list(awkward1.pad_none(array, 3, axis=-3,
clip=True)) == [[[0.0, 1.1, 2.2],
[], [3.3, 4.4]],
[], None]
assert awkward1.to_list(awkward1.pad_none(
array, 2, axis=1, clip=True)) == [[[0.0, 1.1, 2.2], []], [None, None],
None, None, [[], [10.0, 11.1, 12.2]]]
assert awkward1.to_list(awkward1.pad_none(
array, 2, axis=-2, clip=True)) == [[[0.0, 1.1, 2.2], []],
[None, None], None, None,
[[], [10.0, 11.1, 12.2]]]
assert awkward1.to_list(awkward1.pad_none(array, 2, axis=2,
clip=True)) == [[[0.0, 1.1],
[None, None],
[3.3, 4.4]], [],
None, None,
[[None, None],
[10.0, 11.1]]]
assert awkward1.to_list(awkward1.pad_none(array, 2, axis=-1,
clip=True)) == [[[0.0, 1.1],
[None, None],
[3.3, 4.4]], [],
None, None,
[[None, None],
[10.0, 11.1]]]
def test_array_slice():
array = awkward1.Array([0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9],
check_valid=True)
assert awkward1.to_list(array[[5, 2, 2, 3, 9, 0,
1]]) == [5.5, 2.2, 2.2, 3.3, 9.9, 0.0, 1.1]
assert awkward1.to_list(array[numpy.array(
[5, 2, 2, 3, 9, 0, 1])]) == [5.5, 2.2, 2.2, 3.3, 9.9, 0.0, 1.1]
assert awkward1.to_list(array[awkward1.layout.NumpyArray(
numpy.array([5, 2, 2, 3, 9, 0, 1], dtype=numpy.int32))]) == [
5.5, 2.2, 2.2, 3.3, 9.9, 0.0, 1.1
]
assert awkward1.to_list(array[awkward1.Array(
numpy.array([5, 2, 2, 3, 9, 0, 1], dtype=numpy.int32),
check_valid=True)]) == [5.5, 2.2, 2.2, 3.3, 9.9, 0.0, 1.1]
assert awkward1.to_list(array[awkward1.Array(
[5, 2, 2, 3, 9, 0, 1],
check_valid=True)]) == [5.5, 2.2, 2.2, 3.3, 9.9, 0.0, 1.1]
assert awkward1.to_list(array[awkward1.layout.NumpyArray(
numpy.array([
False, False, False, False, False, True, False, True, False, True
]))]) == [5.5, 7.7, 9.9]
content = awkward1.layout.NumpyArray(
numpy.array([1, 0, 9, 3, 2, 2, 5], dtype=numpy.int64))
index = awkward1.layout.Index64(
numpy.array([6, 5, 4, 3, 2, 1, 0], dtype=numpy.int64))
indexedarray = awkward1.layout.IndexedArray64(index, content)
assert awkward1.to_list(
array[indexedarray]) == [5.5, 2.2, 2.2, 3.3, 9.9, 0.0, 1.1]
assert awkward1.to_list(array[awkward1.Array(
indexedarray,
check_valid=True)]) == [5.5, 2.2, 2.2, 3.3, 9.9, 0.0, 1.1]
assert awkward1.to_list(array[awkward1.layout.EmptyArray()]) == []
content0 = awkward1.layout.NumpyArray(numpy.array([5, 2, 2]))
content1 = awkward1.layout.NumpyArray(numpy.array([3, 9, 0, 1]))
tags = awkward1.layout.Index8(
numpy.array([0, 0, 0, 1, 1, 1, 1], dtype=numpy.int8))
index2 = awkward1.layout.Index64(
numpy.array([0, 1, 2, 0, 1, 2, 3], dtype=numpy.int64))
unionarray = awkward1.layout.UnionArray8_64(tags, index2,
[content0, content1])
assert awkward1.to_list(
array[unionarray]) == [5.5, 2.2, 2.2, 3.3, 9.9, 0.0, 1.1]
assert awkward1.to_list(array[awkward1.Array(
unionarray, check_valid=True)]) == [5.5, 2.2, 2.2, 3.3, 9.9, 0.0, 1.1]
array = awkward1.Array(numpy.array([[0.0, 1.1, 2.2, 3.3, 4.4],
[5.5, 6.6, 7.7, 8.8, 9.9]]),
check_valid=True)
assert awkward1.to_list(
array[awkward1.layout.NumpyArray(numpy.array([[0, 1], [1, 0]])),
awkward1.layout.NumpyArray(numpy.array([[2, 4], [3, 3]]))]) == [[
2.2, 9.9
], [8.8, 3.3]]
assert awkward1.to_list(array[awkward1.layout.NumpyArray(
numpy.array([[0, 1], [1, 0]]))]) == [[[0.0, 1.1, 2.2, 3.3, 4.4],
[5.5, 6.6, 7.7, 8.8, 9.9]],
[[5.5, 6.6, 7.7, 8.8, 9.9],
[0.0, 1.1, 2.2, 3.3, 4.4]]]
array = awkward1.Array([{
"x": 1,
"y": 1.1,
"z": [1]
}, {
"x": 2,
"y": 2.2,
"z": [2, 2]
}, {
"x": 3,
"y": 3.3,
"z": [3, 3, 3]
}, {
"x": 4,
"y": 4.4,
"z": [4, 4, 4, 4]
}, {
"x": 5,
"y": 5.5,
"z": [5, 5, 5, 5, 5]
}],
check_valid=True)
awkward1.to_list(array[awkward1.from_iter(["y", "x"],
highlevel=False)]) == [{
"y": 1.1,
"x": 1
}, {
"y": 2.2,
"x": 2
}, {
"y": 3.3,
"x": 3
}, {
"y": 4.4,
"x": 4
}, {
"y": 5.5,
"x": 5
}]
def test_indexedarray2b():
array = awkward1.from_iter([[0.0, 1.1, 2.2], [3.3, 4.4], [5.5], [6.6, 7.7, 8.8, 9.9]], highlevel=False)
index = awkward1.layout.Index64(numpy.array([0, -1, 2, 3], dtype=numpy.int64))
indexedarray = awkward1.layout.IndexedOptionArray64(index, array)
assert awkward1.to_list(indexedarray) == [[0.0, 1.1, 2.2], None, [5.5], [6.6, 7.7, 8.8, 9.9]]
assert awkward1.to_list(indexedarray[awkward1.Array([[1, 1], None, [0], [0, -1]])]) == [[1.1, 1.1], None, [5.5], [6.6, 9.9]]
def test_recordarray():
layout = awkward1.from_iter([{"x": 0.0, "y": []}, {"x": 1.1, "y": [1]}, {"x": 2.2, "y": [2, 2]}, {"x": 3.3, "y": [3, 3, 3]}, {"x": 4.4, "y": [4, 4, 4, 4]}], highlevel=False)
numbatype = awkward1._connect._numba.arrayview.tonumbatype(layout.form)
assert awkward1_connect_numba_layout.typeof(layout).name == numbatype.name
lookup1 = awkward1_connect_numba_arrayview.Lookup(layout)
lookup2 = awkward1_connect_numba_arrayview.Lookup(layout.form)
numbatype.form_fill(0, layout, lookup2)
assert numpy.array_equal(lookup1.arrayptrs, lookup2.arrayptrs)
assert numpy.array_equal(lookup1.sharedptrs == -1, lookup2.sharedptrs == -1)
counter = [0]
def materialize():
counter[0] += 1
return layout
generator = awkward1.layout.ArrayGenerator(materialize, form=layout.form, length=len(layout))
virtualarray = awkward1.layout.VirtualArray(generator)
lookup3 = awkward1_connect_numba_arrayview.Lookup(virtualarray)
assert len(lookup1.arrayptrs) + 3 == len(lookup3.arrayptrs)
array = awkward1.Array(virtualarray)
array.numba_type
assert counter[0] == 0
@numba.njit
def f3(x):
return x
assert isinstance(f3(array).layout, awkward1.layout.VirtualArray)
assert counter[0] == 0
@numba.njit
def f1a(x):
return x["x"][2]
assert f1a(array) == 2.2
assert counter[0] == 1
assert f1a(array) == 2.2
assert counter[0] == 1
@numba.njit
def f1b(x):
return x[2]["x"]
assert f1b(array) == 2.2
assert counter[0] == 1
assert f1b(array) == 2.2
assert counter[0] == 1
@numba.njit
def f1c(x):
return x.x[2]
assert f1c(array) == 2.2
assert counter[0] == 1
assert f1c(array) == 2.2
assert counter[0] == 1
@numba.njit
def f1d(x):
return x[2].x
assert f1d(array) == 2.2
assert counter[0] == 1
assert f1d(array) == 2.2
assert counter[0] == 1
@numba.njit
def f2a(x):
return x["y"][2]
assert awkward1.to_list(f2a(array)) == [2, 2]
assert counter[0] == 1
assert awkward1.to_list(f2a(array)) == [2, 2]
assert counter[0] == 1
@numba.njit
def f2b(x):
return x[2]["y"]
assert awkward1.to_list(f2b(array)) == [2, 2]
assert counter[0] == 1
assert awkward1.to_list(f2b(array)) == [2, 2]
assert counter[0] == 1
@numba.njit
def f2c(x):
return x.y[2]
assert awkward1.to_list(f2a(array)) == [2, 2]
assert counter[0] == 1
assert awkward1.to_list(f2a(array)) == [2, 2]
assert counter[0] == 1
@numba.njit
def f2d(x):
return x[2].y
assert awkward1.to_list(f2b(array)) == [2, 2]
assert counter[0] == 1
assert awkward1.to_list(f2b(array)) == [2, 2]
assert counter[0] == 1
assert awkward1.to_list(f3(array)) == [{"x": 0.0, "y": []}, {"x": 1.1, "y": [1]}, {"x": 2.2, "y": [2, 2]}, {"x": 3.3, "y": [3, 3, 3]}, {"x": 4.4, "y": [4, 4, 4, 4]}]
def test_bytemaskedarray2b():
array = awkward1.from_iter([[0.0, 1.1, 2.2], [3.3, 4.4], [5.5], [6.6, 7.7, 8.8, 9.9]], highlevel=False)
mask = awkward1.layout.Index8(numpy.array([0, 1, 0, 0], dtype=numpy.int8))
maskedarray = awkward1.layout.ByteMaskedArray(mask, array, valid_when=False)
assert awkward1.to_list(maskedarray) == [[0.0, 1.1, 2.2], None, [5.5], [6.6, 7.7, 8.8, 9.9]]
assert awkward1.to_list(maskedarray[awkward1.Array([[1, 1], None, [0], [0, -1]])]) == [[1.1, 1.1], None, [5.5], [6.6, 9.9]]
def test_tuplearray():
layout = awkward1.from_iter([(0.0, []), (1.1, [1]), (2.2, [2, 2]), (3.3, [3, 3, 3]), (4.4, [4, 4, 4, 4])], highlevel=False)
numbatype = awkward1._connect._numba.arrayview.tonumbatype(layout.form)
assert awkward1_connect_numba_layout.typeof(layout).name == numbatype.name
lookup1 = awkward1_connect_numba_arrayview.Lookup(layout)
lookup2 = awkward1_connect_numba_arrayview.Lookup(layout.form)
numbatype.form_fill(0, layout, lookup2)
assert numpy.array_equal(lookup1.arrayptrs, lookup2.arrayptrs)
assert numpy.array_equal(lookup1.sharedptrs == -1, lookup2.sharedptrs == -1)
counter = [0]
def materialize():
counter[0] += 1
return layout
generator = awkward1.layout.ArrayGenerator(materialize, form=layout.form, length=len(layout))
virtualarray = awkward1.layout.VirtualArray(generator)
lookup3 = awkward1_connect_numba_arrayview.Lookup(virtualarray)
assert len(lookup1.arrayptrs) + 3 == len(lookup3.arrayptrs)
array = awkward1.Array(virtualarray)
array.numba_type
assert counter[0] == 0
@numba.njit
def f3(x):
return x
assert isinstance(f3(array).layout, awkward1.layout.VirtualArray)
assert counter[0] == 0
@numba.njit
def f1a(x):
return x["0"][2]
assert f1a(array) == 2.2
assert counter[0] == 1
assert f1a(array) == 2.2
assert counter[0] == 1
@numba.njit
def f1b(x):
return x[2]["0"]
assert f1b(array) == 2.2
assert counter[0] == 1
assert f1b(array) == 2.2
assert counter[0] == 1
@numba.njit
def f2a(x):
return x["1"][2]
assert awkward1.to_list(f2a(array)) == [2, 2]
assert counter[0] == 1
assert awkward1.to_list(f2a(array)) == [2, 2]
assert counter[0] == 1
@numba.njit
def f2b(x):
return x[2]["1"]
assert awkward1.to_list(f2b(array)) == [2, 2]
assert counter[0] == 1
assert awkward1.to_list(f2b(array)) == [2, 2]
assert counter[0] == 1
assert awkward1.to_list(f3(array)) == [(0.0, []), (1.1, [1]), (2.2, [2, 2]), (3.3, [3, 3, 3]), (4.4, [4, 4, 4, 4])]
def test_basic():
one = awkward1.from_iter([[1.1, 2.2, 3.3], [], [4.4, 5.5]],
highlevel=False)
two = awkward1.from_iter([[6.6], [], [], [], [7.7, 8.8, 9.9]],
highlevel=False)
array = awkward1.partition.IrregularlyPartitionedArray([one, two])
assert len(array) == 8
assert [awkward1.to_list(x)
for x in array.partitions] == [[[1.1, 2.2, 3.3], [], [4.4, 5.5]],
[[6.6], [], [], [], [7.7, 8.8,
9.9]]]
assert awkward1.to_list(array.partition(0)) == [[1.1, 2.2, 3.3], [],
[4.4, 5.5]]
assert awkward1.to_list(array.partition(1)) == [[6.6], [], [], [],
[7.7, 8.8, 9.9]]
assert array.start(0) == 0
assert array.start(1) == 3
assert array.stop(0) == 3
assert array.stop(1) == 8
assert array.partitionid_index_at(0) == (0, 0)
assert array.partitionid_index_at(1) == (0, 1)
assert array.partitionid_index_at(2) == (0, 2)
assert array.partitionid_index_at(3) == (1, 0)
assert array.partitionid_index_at(4) == (1, 1)
assert array.partitionid_index_at(5) == (1, 2)
assert array.partitionid_index_at(6) == (1, 3)
assert array.partitionid_index_at(7) == (1, 4)
assert array.tojson(
) == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
assert awkward1.to_list(array._ext.getitem_at(0)) == [1.1, 2.2, 3.3]
assert awkward1.to_list(array._ext.getitem_at(1)) == []
assert awkward1.to_list(array._ext.getitem_at(2)) == [4.4, 5.5]
assert awkward1.to_list(array._ext.getitem_at(3)) == [6.6]
assert awkward1.to_list(array._ext.getitem_at(4)) == []
assert awkward1.to_list(array._ext.getitem_at(5)) == []
assert awkward1.to_list(array._ext.getitem_at(6)) == []
assert awkward1.to_list(array._ext.getitem_at(7)) == [7.7, 8.8, 9.9]
assert awkward1.to_list(array._ext.getitem_at(-1)) == [7.7, 8.8, 9.9]
assert awkward1.to_list(array._ext.getitem_at(-2)) == []
assert awkward1.to_list(array._ext.getitem_at(-3)) == []
assert awkward1.to_list(array._ext.getitem_at(-4)) == []
assert awkward1.to_list(array._ext.getitem_at(-5)) == [6.6]
assert awkward1.to_list(array._ext.getitem_at(-6)) == [4.4, 5.5]
assert awkward1.to_list(array._ext.getitem_at(-7)) == []
assert awkward1.to_list(array._ext.getitem_at(-8)) == [1.1, 2.2, 3.3]
assert array._ext.getitem_range(0, 8, 1).tojson(
) == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(
1, 8, 1).tojson() == "[[],[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(
2, 8, 1).tojson() == "[[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(
3, 8, 1).tojson() == "[[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(4, 8,
1).tojson() == "[[],[],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(5, 8,
1).tojson() == "[[],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(6, 8, 1).tojson() == "[[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(7, 8, 1).tojson() == "[[7.7,8.8,9.9]]"
assert array._ext.getitem_range(8, 8, 1).tojson() == "[]"
assert array._ext.getitem_range(-1, 8, 1).tojson() == "[[7.7,8.8,9.9]]"
assert array._ext.getitem_range(-2, 8, 1).tojson() == "[[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(-3, 8,
1).tojson() == "[[],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(-4, 8,
1).tojson() == "[[],[],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(
-5, 8, 1).tojson() == "[[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(
-6, 8, 1).tojson() == "[[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(
-7, 8, 1).tojson() == "[[],[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(-8, 8, 1).tojson(
) == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(0, 8, 1).tojson(
) == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(
0, 7, 1).tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[],[]]"
assert array._ext.getitem_range(
0, 6, 1).tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[]]"
assert array._ext.getitem_range(
0, 5, 1).tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[]]"
assert array._ext.getitem_range(
0, 4, 1).tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6]]"
assert array._ext.getitem_range(
0, 3, 1).tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5]]"
assert array._ext.getitem_range(0, 2, 1).tojson() == "[[1.1,2.2,3.3],[]]"
assert array._ext.getitem_range(0, 1, 1).tojson() == "[[1.1,2.2,3.3]]"
assert array._ext.getitem_range(0, 0, 1).tojson() == "[]"
assert array._ext.getitem_range(0, -8, 1).tojson() == "[]"
assert array._ext.getitem_range(0, -7, 1).tojson() == "[[1.1,2.2,3.3]]"
assert array._ext.getitem_range(0, -6, 1).tojson() == "[[1.1,2.2,3.3],[]]"
assert array._ext.getitem_range(
0, -5, 1).tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5]]"
assert array._ext.getitem_range(
0, -4, 1).tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6]]"
assert array._ext.getitem_range(
0, -3, 1).tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[]]"
assert array._ext.getitem_range(
0, -2, 1).tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[]]"
assert array._ext.getitem_range(
0, -1, 1).tojson() == "[[1.1,2.2,3.3],[],[4.4,5.5],[6.6],[],[],[]]"
assert array._ext.getitem_range(
0, 8, 2).tojson() == "[[1.1,2.2,3.3],[4.4,5.5],[],[]]"
assert array._ext.getitem_range(
1, 8, 2).tojson() == "[[],[6.6],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(1, 7, 2).tojson() == "[[],[6.6],[]]"
assert array._ext.getitem_range(2, 8, 2).tojson() == "[[4.4,5.5],[],[]]"
assert array._ext.getitem_range(3, 8,
2).tojson() == "[[6.6],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(0, 8,
3).tojson() == "[[1.1,2.2,3.3],[6.6],[]]"
assert array._ext.getitem_range(1, 8,
3).tojson() == "[[],[],[7.7,8.8,9.9]]"
assert array._ext.getitem_range(1, 7, 3).tojson() == "[[],[]]"
assert array._ext.getitem_range(2, 8, 3).tojson() == "[[4.4,5.5],[]]"
assert array._ext.getitem_range(3, 8, 3).tojson() == "[[6.6],[]]"
assert array._ext.getitem_range(2, 0, -1).tojson() == "[[4.4,5.5],[]]"
assert array._ext.getitem_range(
2, None, -1).tojson() == "[[4.4,5.5],[],[1.1,2.2,3.3]]"
assert array._ext.getitem_range(1, None,
-1).tojson() == "[[],[1.1,2.2,3.3]]"
assert array._ext.getitem_range(
3, None, -1).tojson() == "[[6.6],[4.4,5.5],[],[1.1,2.2,3.3]]"
assert array._ext.getitem_range(None, None, -1).tojson(
) == "[[7.7,8.8,9.9],[],[],[],[6.6],[4.4,5.5],[],[1.1,2.2,3.3]]"
assert array._ext.getitem_range(-1, None, -1).tojson(
) == "[[7.7,8.8,9.9],[],[],[],[6.6],[4.4,5.5],[],[1.1,2.2,3.3]]"
assert array._ext.getitem_range(
-2, None, -1).tojson() == "[[],[],[],[6.6],[4.4,5.5],[],[1.1,2.2,3.3]]"
assert array._ext.getitem_range(
-2, 0, -1).tojson() == "[[],[],[],[6.6],[4.4,5.5],[]]"
assert array._ext.getitem_range(
-2, 1, -1).tojson() == "[[],[],[],[6.6],[4.4,5.5]]"
assert array._ext.getitem_range(-2, 2, -1).tojson() == "[[],[],[],[6.6]]"
assert array._ext.getitem_range(-1, 3,
-1).tojson() == "[[7.7,8.8,9.9],[],[],[]]"
assert array._ext.getitem_range(
-1, None, -2).tojson() == "[[7.7,8.8,9.9],[],[6.6],[]]"
assert array._ext.getitem_range(
-2, None, -2).tojson() == "[[],[],[4.4,5.5],[1.1,2.2,3.3]]"
assert array._ext.getitem_range(-1, None,
-3).tojson() == "[[7.7,8.8,9.9],[],[]]"
assert array._ext.getitem_range(-2, None,
-3).tojson() == "[[],[6.6],[1.1,2.2,3.3]]"
assert array._ext.getitem_range(-3, None, -3).tojson() == "[[],[4.4,5.5]]"
assert array._ext.getitem_range(-4, None, -3).tojson() == "[[],[]]"
assert array._ext.getitem_range(-5, None,
-3).tojson() == "[[6.6],[1.1,2.2,3.3]]"
assert array._ext.getitem_range(-2, 0, -2).tojson() == "[[],[],[4.4,5.5]]"
assert [awkward1.to_list(x) for x in array] == [[1.1, 2.2, 3.3], [],
[4.4, 5.5], [6.6], [], [],
[], [7.7, 8.8, 9.9]]
assert awkward1.to_list(array.toContent()) == [[1.1, 2.2, 3.3], [],
[4.4, 5.5], [6.6], [], [],
[], [7.7, 8.8, 9.9]]
def test_deep_virtualarrays():
one = awkward1.from_iter([0.0, 1.1, 2.2, 3.3, 4.4], highlevel=False)
two = awkward1.from_iter([[], [1], [2, 2], [3, 3, 3], [4, 4, 4, 4]], highlevel=False)
counter = [0, 0]
def materialize1():
counter[0] += 1
return one
generator1 = awkward1.layout.ArrayGenerator(materialize1, form=one.form, length=len(one))
vone = awkward1.layout.VirtualArray(generator1)
def materialize2():
counter[1] += 1
return two
generator2 = awkward1.layout.ArrayGenerator(materialize2, form=two.form, length=len(two))
vtwo = awkward1.layout.VirtualArray(generator2)
recordarray = awkward1.layout.RecordArray([vone, vtwo], ["x", "y"])
array = awkward1.Array(recordarray)
array.numba_type
assert counter == [0, 0]
@numba.njit
def f3(x):
return x
tmp1 = f3(array).layout
assert isinstance(tmp1, awkward1.layout.RecordArray)
assert isinstance(tmp1.field(0), awkward1.layout.VirtualArray)
assert isinstance(tmp1.field(1), awkward1.layout.VirtualArray)
assert counter == [0, 0]
@numba.njit
def f1a(x):
return x["x"]
tmp2a = f1a(array).layout
assert isinstance(tmp2a, awkward1.layout.VirtualArray)
assert counter == [0, 0]
@numba.njit
def f1b(x):
return x["x"][2]
tmp2b = f1b(array)
assert tmp2b == 2.2
assert counter == [1, 0]
@numba.njit
def f2a(x):
return x["y"]
tmp3a = f2a(array).layout
assert isinstance(tmp3a, awkward1.layout.VirtualArray)
assert counter == [1, 0]
@numba.njit
def f2b(x):
return x["y"][2]
tmp3b = f2b(array).layout
assert isinstance(tmp3b, awkward1.layout.NumpyArray)
assert awkward1.to_list(tmp3b) == [2, 2]
assert counter == [1, 1]
def test_recordarray_merge():
emptyarray = awkward1.layout.EmptyArray()
arrayr1 = awkward1.from_iter([{"x": 0, "y": []}, {"x": 1, "y": [1, 1]}, {"x": 2, "y": [2, 2]}], highlevel=False)
arrayr2 = awkward1.from_iter([{"x": 2.2, "y": [2.2, 2.2]}, {"x": 1.1, "y": [1.1, 1.1]}, {"x": 0.0, "y": [0.0, 0.0]}], highlevel=False)
arrayr3 = awkward1.from_iter([{"x": 0, "y": 0.0}, {"x": 1, "y": 1.1}, {"x": 2, "y": 2.2}], highlevel=False)
arrayr4 = awkward1.from_iter([{"y": [], "x": 0}, {"y": [1, 1], "x": 1}, {"y": [2, 2], "x": 2}], highlevel=False)
arrayr5 = awkward1.from_iter([{"x": 0, "y": [], "z": 0}, {"x": 1, "y": [1, 1], "z": 1}, {"x": 2, "y": [2, 2], "z": 2}], highlevel=False)
arrayr6 = awkward1.from_iter([{"z": 0, "x": 0, "y": []}, {"z": 1, "x": 1, "y": [1, 1]}, {"z": 2, "x": 2, "y": [2, 2]}], highlevel=False)
arrayr7 = awkward1.from_iter([{"x": 0}, {"x": 1}, {"x": 2}], highlevel=False)
arrayt1 = awkward1.from_iter([(0, []), (1, [1.1]), (2, [2, 2])], highlevel=False)
arrayt2 = awkward1.from_iter([(2.2, [2.2, 2.2]), (1.1, [1.1, 1.1]), (0.0, [0.0, 0.0])], highlevel=False)
arrayt3 = awkward1.from_iter([(0, 0.0), (1, 1.1), (2, 2.2)], highlevel=False)
arrayt4 = awkward1.from_iter([([], 0), ([1.1], 1), ([2.2, 2.2], 2)], highlevel=False)
arrayt5 = awkward1.from_iter([(0, [], 0), (1, [1], 1), (2, [2, 2], 2)], highlevel=False)
arrayt6 = awkward1.from_iter([(0, 0, []), (1, 1, [1]), (2, 2, [2, 2])], highlevel=False)
arrayt7 = awkward1.from_iter([(0,), (1,), (2,)], highlevel=False)
assert arrayr1.mergeable(arrayr2)
assert arrayr2.mergeable(arrayr1)
assert not arrayr1.mergeable(arrayr3)
assert arrayr1.mergeable(arrayr4)
assert arrayr4.mergeable(arrayr1)
assert not arrayr1.mergeable(arrayr5)
assert not arrayr1.mergeable(arrayr6)
assert arrayr5.mergeable(arrayr6)
assert arrayr6.mergeable(arrayr5)
assert not arrayr1.mergeable(arrayr7)
assert arrayt1.mergeable(arrayt2)
assert arrayt2.mergeable(arrayt1)
assert not arrayt1.mergeable(arrayt3)
assert not arrayt1.mergeable(arrayt4)
assert not arrayt1.mergeable(arrayt5)
assert not arrayt1.mergeable(arrayt6)
assert not arrayt5.mergeable(arrayt6)
assert not arrayt1.mergeable(arrayt7)
assert awkward1.to_list(arrayr1.merge(arrayr2)) == [{"x": 0.0, "y": []}, {"x": 1.0, "y": [1.0, 1.0]}, {"x": 2.0, "y": [2.0, 2.0]}, {"x": 2.2, "y": [2.2, 2.2]}, {"x": 1.1, "y": [1.1, 1.1]}, {"x": 0.0, "y": [0.0, 0.0]}]
assert awkward1.to_list(arrayr2.merge(arrayr1)) == [{"x": 2.2, "y": [2.2, 2.2]}, {"x": 1.1, "y": [1.1, 1.1]}, {"x": 0.0, "y": [0.0, 0.0]}, {"x": 0.0, "y": []}, {"x": 1.0, "y": [1.0, 1.0]}, {"x": 2.0, "y": [2.0, 2.0]}]
assert awkward1.to_list(arrayr1.merge(arrayr4)) == [{"x": 0, "y": []}, {"x": 1, "y": [1, 1]}, {"x": 2, "y": [2, 2]}, {"x": 0, "y": []}, {"x": 1, "y": [1, 1]}, {"x": 2, "y": [2, 2]}]
assert awkward1.to_list(arrayr4.merge(arrayr1)) == [{"x": 0, "y": []}, {"x": 1, "y": [1, 1]}, {"x": 2, "y": [2, 2]}, {"x": 0, "y": []}, {"x": 1, "y": [1, 1]}, {"x": 2, "y": [2, 2]}]
assert awkward1.to_list(arrayr5.merge(arrayr6)) == [{"x": 0, "y": [], "z": 0}, {"x": 1, "y": [1, 1], "z": 1}, {"x": 2, "y": [2, 2], "z": 2}, {"x": 0, "y": [], "z": 0}, {"x": 1, "y": [1, 1], "z": 1}, {"x": 2, "y": [2, 2], "z": 2}]
assert awkward1.to_list(arrayr6.merge(arrayr5)) == [{"x": 0, "y": [], "z": 0}, {"x": 1, "y": [1, 1], "z": 1}, {"x": 2, "y": [2, 2], "z": 2}, {"x": 0, "y": [], "z": 0}, {"x": 1, "y": [1, 1], "z": 1}, {"x": 2, "y": [2, 2], "z": 2}]
assert awkward1.to_list(arrayt1.merge(arrayt2)) == [(0.0, []), (1.0, [1.1]), (2.0, [2.0, 2.0]), (2.2, [2.2, 2.2]), (1.1, [1.1, 1.1]), (0.0, [0.0, 0.0])]
assert awkward1.to_list(arrayt2.merge(arrayt1)) == [(2.2, [2.2, 2.2]), (1.1, [1.1, 1.1]), (0.0, [0.0, 0.0]), (0.0, []), (1.0, [1.1]), (2.0, [2.0, 2.0])]
assert awkward1.to_list(arrayr1.merge(emptyarray)) == awkward1.to_list(arrayr1)
assert awkward1.to_list(arrayr2.merge(emptyarray)) == awkward1.to_list(arrayr2)
assert awkward1.to_list(arrayr3.merge(emptyarray)) == awkward1.to_list(arrayr3)
assert awkward1.to_list(arrayr4.merge(emptyarray)) == awkward1.to_list(arrayr4)
assert awkward1.to_list(arrayr5.merge(emptyarray)) == awkward1.to_list(arrayr5)
assert awkward1.to_list(arrayr6.merge(emptyarray)) == awkward1.to_list(arrayr6)
assert awkward1.to_list(arrayr7.merge(emptyarray)) == awkward1.to_list(arrayr7)
assert awkward1.to_list(emptyarray.merge(arrayr1)) == awkward1.to_list(arrayr1)
assert awkward1.to_list(emptyarray.merge(arrayr2)) == awkward1.to_list(arrayr2)
assert awkward1.to_list(emptyarray.merge(arrayr3)) == awkward1.to_list(arrayr3)
assert awkward1.to_list(emptyarray.merge(arrayr4)) == awkward1.to_list(arrayr4)
assert awkward1.to_list(emptyarray.merge(arrayr5)) == awkward1.to_list(arrayr5)
assert awkward1.to_list(emptyarray.merge(arrayr6)) == awkward1.to_list(arrayr6)
assert awkward1.to_list(emptyarray.merge(arrayr7)) == awkward1.to_list(arrayr7)
assert awkward1.to_list(arrayt1.merge(emptyarray)) == awkward1.to_list(arrayt1)
assert awkward1.to_list(arrayt2.merge(emptyarray)) == awkward1.to_list(arrayt2)
assert awkward1.to_list(arrayt3.merge(emptyarray)) == awkward1.to_list(arrayt3)
assert awkward1.to_list(arrayt4.merge(emptyarray)) == awkward1.to_list(arrayt4)
assert awkward1.to_list(arrayt5.merge(emptyarray)) == awkward1.to_list(arrayt5)
assert awkward1.to_list(arrayt6.merge(emptyarray)) == awkward1.to_list(arrayt6)
assert awkward1.to_list(arrayt7.merge(emptyarray)) == awkward1.to_list(arrayt7)
assert awkward1.to_list(emptyarray.merge(arrayt1)) == awkward1.to_list(arrayt1)
assert awkward1.to_list(emptyarray.merge(arrayt2)) == awkward1.to_list(arrayt2)
assert awkward1.to_list(emptyarray.merge(arrayt3)) == awkward1.to_list(arrayt3)
assert awkward1.to_list(emptyarray.merge(arrayt4)) == awkward1.to_list(arrayt4)
assert awkward1.to_list(emptyarray.merge(arrayt5)) == awkward1.to_list(arrayt5)
assert awkward1.to_list(emptyarray.merge(arrayt6)) == awkward1.to_list(arrayt6)
assert awkward1.to_list(emptyarray.merge(arrayt7)) == awkward1.to_list(arrayt7)
def test_getitem():
content0 = awkward1.from_iter([[1.1, 2.2, 3.3], [], [4.4, 5.5]],
highlevel=False)
content1 = awkward1.from_iter(["one", "two", "three", "four", "five"],
highlevel=False)
tags = awkward1.layout.Index8(
numpy.array([1, 1, 0, 0, 1, 0, 1, 1], dtype=numpy.int8))
assert numpy.asarray(
awkward1.layout.UnionArray8_32.regular_index(tags)).tolist() == [
0, 1, 0, 1, 2, 2, 3, 4
]
assert numpy.asarray(awkward1.layout.UnionArray8_32.regular_index(
tags)).dtype == numpy.dtype(numpy.int32)
assert numpy.asarray(
awkward1.layout.UnionArray8_U32.regular_index(tags)).tolist() == [
0, 1, 0, 1, 2, 2, 3, 4
]
assert numpy.asarray(awkward1.layout.UnionArray8_U32.regular_index(
tags)).dtype == numpy.dtype(numpy.uint32)
assert numpy.asarray(
awkward1.layout.UnionArray8_64.regular_index(tags)).tolist() == [
0, 1, 0, 1, 2, 2, 3, 4
]
assert numpy.asarray(awkward1.layout.UnionArray8_64.regular_index(
tags)).dtype == numpy.dtype(numpy.int64)
index = awkward1.layout.Index32(
numpy.array([0, 1, 0, 1, 2, 2, 4, 3], dtype=numpy.int32))
array = awkward1.layout.UnionArray8_32(tags, index, [content0, content1])
assert numpy.asarray(array.tags).tolist() == [1, 1, 0, 0, 1, 0, 1, 1]
assert numpy.asarray(array.tags).dtype == numpy.dtype(numpy.int8)
assert numpy.asarray(array.index).tolist() == [0, 1, 0, 1, 2, 2, 4, 3]
assert numpy.asarray(array.index).dtype == numpy.dtype(numpy.int32)
assert type(array.contents) is list
assert [awkward1.to_list(x) for x in array.contents
] == [[[1.1, 2.2, 3.3], [], [4.4, 5.5]],
["one", "two", "three", "four", "five"]]
assert array.numcontents == 2
assert awkward1.to_list(array.content(0)) == [[1.1, 2.2, 3.3], [],
[4.4, 5.5]]
assert awkward1.to_list(
array.content(1)) == ["one", "two", "three", "four", "five"]
assert awkward1.to_list(array.project(0)) == [[1.1, 2.2, 3.3], [],
[4.4, 5.5]]
assert awkward1.to_list(
array.project(1)) == ["one", "two", "three", "five", "four"]
repr(array)
assert awkward1.to_list(array[0]) == "one"
assert awkward1.to_list(array[1]) == "two"
assert awkward1.to_list(array[2]) == [1.1, 2.2, 3.3]
assert awkward1.to_list(array[3]) == []
assert awkward1.to_list(array[4]) == "three"
assert awkward1.to_list(array[5]) == [4.4, 5.5]
assert awkward1.to_list(array[6]) == "five"
assert awkward1.to_list(array[7]) == "four"
assert awkward1.to_list(array) == [
"one", "two", [1.1, 2.2, 3.3], [], "three", [4.4, 5.5], "five", "four"
]
assert awkward1.to_list(array[1:-1]) == [
"two", [1.1, 2.2, 3.3], [], "three", [4.4, 5.5], "five"
]
assert awkward1.to_list(array[2:-2]) == [[1.1, 2.2, 3.3], [], "three",
[4.4, 5.5]]
assert awkward1.to_list(
array[::2]) == ["one", [1.1, 2.2, 3.3], "three", "five"]
assert awkward1.to_list(array[::2,
1:]) == ["ne", [2.2, 3.3], "hree", "ive"]
assert awkward1.to_list(array[:, :-1]) == [
"on", "tw", [1.1, 2.2], [], "thre", [4.4], "fiv", "fou"
]
content2 = awkward1.from_iter([{
"x": 0,
"y": []
}, {
"x": 1,
"y": [1.1]
}, {
"x": 2,
"y": [1.1, 2.2]
}],
highlevel=False)
content3 = awkward1.from_iter([{
"x": 0.0,
"y": "zero",
"z": False
}, {
"x": 1.1,
"y": "one",
"z": True
}, {
"x": 2.2,
"y": "two",
"z": False
}, {
"x": 3.3,
"y": "three",
"z": True
}, {
"x": 4.4,
"y": "four",
"z": False
}],
highlevel=False)
array2 = awkward1.layout.UnionArray8_32(tags, index, [content2, content3])
assert awkward1.to_list(array2) == [{
"x": 0.0,
"y": "zero",
"z": False
}, {
"x": 1.1,
"y": "one",
"z": True
}, {
"x": 0,
"y": []
}, {
"x": 1,
"y": [1.1]
}, {
"x": 2.2,
"y": "two",
"z": False
}, {
"x": 2,
"y": [1.1, 2.2]
}, {
"x": 4.4,
"y": "four",
"z": False
}, {
"x": 3.3,
"y": "three",
"z": True
}]
assert awkward1.to_list(array2["x"]) == [0.0, 1.1, 0, 1, 2.2, 2, 4.4, 3.3]
assert awkward1.to_list(array2["y"]) == [
"zero", "one", [], [1.1], "two", [1.1, 2.2], "four", "three"
]
assert awkward1.to_list(
array2[:, "y",
1:]) == ["ero", "ne", [], [], "wo", [2.2], "our", "hree"]
assert awkward1.to_list(
array2["y", :,
1:]) == ["ero", "ne", [], [], "wo", [2.2], "our", "hree"]
with pytest.raises(ValueError) as err:
array2[:, 1:, "y"]
assert str(err.value) == "in NumpyArray, too many dimensions in slice"
with pytest.raises(ValueError) as err:
array2["z"]
assert str(err.value) == "key \"z\" does not exist (not in record)"
array3 = awkward1.layout.UnionArray8_32(tags, index, [content3, content2])
array4 = awkward1.layout.UnionArray8_32(
tags, index, [content0, content1, content2, content3])
assert set(content2.keys()) == set(["x", "y"])
assert set(content3.keys()) == set(["x", "y", "z"])
assert set(array2.keys()) == set(["x", "y"])
assert set(array3.keys()) == set(["x", "y"])
assert array4.keys() == []
def test_flatten_ListOffsetArray():
array = awkward1.Array([[1.1, 2.2, 3.3], [], [4.4, 5.5]])
assert awkward1.to_list(
awkward1.flatten(array)) == [1.1, 2.2, 3.3, 4.4, 5.5]
assert awkward1.to_list(awkward1.flatten(array[1:])) == [4.4, 5.5]
array = awkward1.Array([[[0.0, 1.1, 2.2], [], [3.3, 4.4]], [], [[5.5]],
[[], [6.6, 7.7, 8.8, 9.9]]])
assert awkward1.to_list(awkward1.flatten(array)) == [[0.0, 1.1, 2.2], [],
[3.3, 4.4], [5.5], [],
[6.6, 7.7, 8.8, 9.9]]
assert awkward1.to_list(awkward1.flatten(
array[1:])) == [[5.5], [], [6.6, 7.7, 8.8, 9.9]]
assert awkward1.to_list(awkward1.flatten(
array[:, 1:])) == [[], [3.3, 4.4], [6.6, 7.7, 8.8, 9.9]]
assert awkward1.to_list(awkward1.flatten(
array, axis=2)) == [[0.0, 1.1, 2.2, 3.3, 4.4], [], [5.5],
[6.6, 7.7, 8.8, 9.9]]
assert awkward1.to_list(awkward1.flatten(array[1:],
axis=2)) == [[], [5.5],
[6.6, 7.7, 8.8, 9.9]]
assert awkward1.to_list(awkward1.flatten(array[:, 1:],
axis=2)) == [[3.3, 4.4], [], [],
[6.6, 7.7, 8.8, 9.9]]
array = awkward1.Array(
numpy.arange(2 * 3 * 5 * 7).reshape(2, 3, 5, 7).tolist())
assert awkward1.to_list(awkward1.flatten(array, axis=1)) == numpy.arange(
2 * 3 * 5 * 7).reshape(2 * 3, 5, 7).tolist()
assert awkward1.to_list(awkward1.flatten(array, axis=2)) == numpy.arange(
2 * 3 * 5 * 7).reshape(2, 3 * 5, 7).tolist()
assert awkward1.to_list(awkward1.flatten(array, axis=3)) == numpy.arange(
2 * 3 * 5 * 7).reshape(2, 3, 5 * 7).tolist()
def toListArray(x):
if isinstance(x, awkward1.layout.ListOffsetArray64):
starts = awkward1.layout.Index64(numpy.asarray(x.offsets)[:-1])
stops = awkward1.layout.Index64(numpy.asarray(x.offsets)[1:])
return awkward1.layout.ListArray64(starts, stops,
toListArray(x.content))
elif isinstance(x, awkward1.layout.ListOffsetArray32):
starts = awkward1.layout.Index64(numpy.asarray(x.offsets)[:-1])
stops = awkward1.layout.Index64(numpy.asarray(x.offsets)[1:])
return awkward1.layout.ListArray32(starts, stops,
toListArray(x.content))
elif isinstance(x, awkward1.layout.ListOffsetArrayU32):
starts = awkward1.layout.Index64(numpy.asarray(x.offsets)[:-1])
stops = awkward1.layout.Index64(numpy.asarray(x.offsets)[1:])
return awkward1.layout.ListArrayU32(starts, stops,
toListArray(x.content))
else:
return x
array = awkward1.Array(
toListArray(
awkward1.from_iter(numpy.arange(2 * 3 * 5 * 7).reshape(2, 3, 5,
7).tolist(),
highlevel=False)))
assert awkward1.to_list(awkward1.flatten(array, axis=1)) == numpy.arange(
2 * 3 * 5 * 7).reshape(2 * 3, 5, 7).tolist()
assert awkward1.to_list(awkward1.flatten(array, axis=2)) == numpy.arange(
2 * 3 * 5 * 7).reshape(2, 3 * 5, 7).tolist()
assert awkward1.to_list(awkward1.flatten(array, axis=3)) == numpy.arange(
2 * 3 * 5 * 7).reshape(2, 3, 5 * 7).tolist()
array = awkward1.Array(numpy.arange(2 * 3 * 5 * 7).reshape(2, 3, 5, 7))
assert awkward1.to_list(awkward1.flatten(array, axis=1)) == numpy.arange(
2 * 3 * 5 * 7).reshape(2 * 3, 5, 7).tolist()
assert awkward1.to_list(awkward1.flatten(array, axis=2)) == numpy.arange(
2 * 3 * 5 * 7).reshape(2, 3 * 5, 7).tolist()
assert awkward1.to_list(awkward1.flatten(array, axis=3)) == numpy.arange(
2 * 3 * 5 * 7).reshape(2, 3, 5 * 7).tolist()
def test_identities():
a = awkward1.from_iter([{
"outer": [{
"x": 0,
"y": []
}, {
"x": 1,
"y": [1]
}, {
"x": 2,
"y": [1, 2]
}]
}, {
"outer": []
}, {
"outer": [{
"x": 3,
"y": [1, 2, 3]
}, {
"x": 4,
"y": [1, 2, 3, 4]
}]
}],
highlevel=False)
a.setidentities()
b = awkward1.from_iter([{
"outer": {
"x": 0,
"y": []
}
}, {
"outer": {
"x": 1,
"y": [1]
}
}, {
"outer": {
"x": 2,
"y": [1, 2]
}
}, {
"outer": {
"x": 3,
"y": [1, 2, 3]
}
}, {
"outer": {
"x": 4,
"y": [1, 2, 3, 4]
}
}],
highlevel=False)
b.setidentities()
assert awkward1.to_list(a) == [{
u'outer': [{
u'x': 0,
u'y': []
}, {
u'x': 1,
u'y': [1]
}, {
u'x': 2,
u'y': [1, 2]
}]
}, {
u'outer': []
}, {
u'outer': [{
u'x': 3,
u'y': [1, 2, 3]
}, {
u'x': 4,
u'y': [1, 2, 3, 4]
}]
}]
assert a.identity == ()
assert a[2].identity == (2, )
assert a[2, "outer"].identity == (2, 'outer')
assert a[2, "outer", 0].identity == (2, 'outer', 0)
assert a[2, "outer", 0, "y"].identity == (2, u'outer', 0, u'y')
assert awkward1.to_list(b) == [{
u'outer': {
u'x': 0,
u'y': []
}
}, {
u'outer': {
u'x': 1,
u'y': [1]
}
}, {
u'outer': {
u'x': 2,
u'y': [1, 2]
}
}, {
u'outer': {
u'x': 3,
u'y': [1, 2, 3]
}
}, {
u'outer': {
u'x': 4,
u'y': [1, 2, 3, 4]
}
}]
assert b.identity == ()
assert b[2].identity == (2, )
assert b[2, "outer"].identity == (2, u'outer')
with pytest.raises(ValueError) as err:
b[2, "outer", 0].identity
assert str(err.value) == "in NumpyArray, too many dimensions in slice"
with pytest.raises(ValueError) as err:
b[2, "outer", 0, "y"].identity
assert str(err.value) == "in NumpyArray, too many dimensions in slice"
def test_recordarray():
array = awkward1.from_iter([{
"x": 0.0,
"y": []
}, {
"x": 1.1,
"y": [1]
}, {
"x": 2.2,
"y": [2, 2]
}, {
"x": 3.3,
"y": [3, 3, 3]
}],
highlevel=False)
assert awkward1.to_list(array.num(0)) == {"x": 4, "y": 4}
array = awkward1.from_iter([{
"x": [3.3, 3.3, 3.3],
"y": []
}, {
"x": [2.2, 2.2],
"y": [1]
}, {
"x": [1.1],
"y": [2, 2]
}, {
"x": [],
"y": [3, 3, 3]
}],
highlevel=False)
assert awkward1.to_list(array.num(0)) == {"x": 4, "y": 4}
assert awkward1.to_list(array.num(1)) == [{
"x": 3,
"y": 0
}, {
"x": 2,
"y": 1
}, {
"x": 1,
"y": 2
}, {
"x": 0,
"y": 3
}]
assert awkward1.to_list(array.num(1)[2]) == {"x": 1, "y": 2}
array = awkward1.from_iter([{
"x": [[3.3, 3.3, 3.3]],
"y": []
}, {
"x": [[2.2, 2.2]],
"y": [1]
}, {
"x": [[1.1]],
"y": [2, 2]
}, {
"x": [[]],
"y": [3, 3, 3]
}],
highlevel=False)
assert awkward1.to_list(array.num(0)) == {"x": 4, "y": 4}
assert awkward1.to_list(array.num(1)) == [{
"x": 1,
"y": 0
}, {
"x": 1,
"y": 1
}, {
"x": 1,
"y": 2
}, {
"x": 1,
"y": 3
}]
assert awkward1.to_list(array.num(1)[2]) == {"x": 1, "y": 2}
def test_toawkward0():
array = awkward1.from_iter([1.1, 2.2, 3.3, 4.4], highlevel=False)
assert isinstance(awkward1.to_awkward0(array), numpy.ndarray)
assert awkward1.to_awkward0(array).tolist() == [1.1, 2.2, 3.3, 4.4]
array = awkward1.from_numpy(numpy.arange(2 * 3 * 5).reshape(2, 3, 5),
highlevel=False).toRegularArray()
assert isinstance(awkward1.to_awkward0(array), awkward0.JaggedArray)
assert awkward1.to_awkward0(array).tolist() == [[[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]]]
array = awkward1.from_iter([[1.1, 2.2, 3.3], [], [4.4, 5.5]],
highlevel=False)
assert isinstance(awkward1.to_awkward0(array), awkward0.JaggedArray)
assert awkward1.to_awkward0(array).tolist() == [[1.1, 2.2, 3.3], [],
[4.4, 5.5]]
array = awkward1.layout.ListArray64(
awkward1.layout.Index64(numpy.array([4, 999, 1], dtype=numpy.int64)),
awkward1.layout.Index64(numpy.array([7, 999, 3], dtype=numpy.int64)),
awkward1.layout.NumpyArray(
numpy.array([3.14, 4.4, 5.5, 123, 1.1, 2.2, 3.3, 321])))
assert isinstance(awkward1.to_awkward0(array), awkward0.JaggedArray)
assert awkward1.to_awkward0(array).tolist() == [[1.1, 2.2, 3.3], [],
[4.4, 5.5]]
array = awkward1.from_iter([{
"x": 0,
"y": []
}, {
"x": 1.1,
"y": [1]
}, {
"x": 2.2,
"y": [2, 2]
}, {
"x": 3.3,
"y": [3, 3, 3]
}],
highlevel=False)
assert isinstance(awkward1.to_awkward0(array[2]), dict)
assert awkward1.to_awkward0(array[2])["x"] == 2.2
assert isinstance(awkward1.to_awkward0(array[2])["y"], numpy.ndarray)
assert awkward1.to_awkward0(array[2])["y"].tolist() == [2, 2]
assert isinstance(awkward1.to_awkward0(array), awkward0.Table)
assert awkward1.to_awkward0(array).tolist() == [{
"x": 0,
"y": []
}, {
"x": 1.1,
"y": [1]
}, {
"x": 2.2,
"y": [2, 2]
}, {
"x": 3.3,
"y": [3, 3, 3]
}]
array = awkward1.from_iter([(0, []), (1.1, [1]), (2.2, [2, 2]),
(3.3, [3, 3, 3])],
highlevel=False)
assert isinstance(awkward1.to_awkward0(array), awkward0.Table)
assert awkward1.to_awkward0(array).tolist() == [(0, []), (1.1, [1]),
(2.2, [2, 2]),
(3.3, [3, 3, 3])]
assert isinstance(awkward1.to_awkward0(array[2]), tuple)
assert awkward1.to_awkward0(array[2])[0] == 2.2
assert awkward1.to_awkward0(array[2])[1].tolist() == [2, 2]
array = awkward1.from_iter(
[0.0, [], 1.1, [1], 2.2, [2, 2], 3.3, [3, 3, 3]], highlevel=False)
assert isinstance(awkward1.to_awkward0(array), awkward0.UnionArray)
assert awkward1.to_awkward0(array).tolist() == [
0.0, [], 1.1, [1], 2.2, [2, 2], 3.3, [3, 3, 3]
]
array = awkward1.from_iter([1.1, 2.2, None, None, 3.3, None, 4.4],
highlevel=False)
assert isinstance(awkward1.to_awkward0(array), awkward0.IndexedMaskedArray)
assert awkward1.to_awkward0(array).tolist() == [
1.1, 2.2, None, None, 3.3, None, 4.4
]
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]))
index = awkward1.layout.Index64(
numpy.array([3, 2, 2, 5, 0], dtype=numpy.int64))
array = awkward1.layout.IndexedArray64(index, content)
assert isinstance(awkward1.to_awkward0(array), awkward0.IndexedArray)
assert awkward1.to_awkward0(array).tolist() == [3.3, 2.2, 2.2, 5.5, 0.0]
