def test_carry():
content = awkward1.layout.NumpyArray(numpy.array([0.0, 1.1, 2.2, 3.3,
4.4]))
index = awkward1.layout.Index64(
numpy.array([2, 2, 0, 3, 4], dtype=numpy.int64))
indexedarray = awkward1.layout.IndexedArray64(index, content)
offsets = awkward1.layout.Index64(
numpy.array([0, 3, 3, 5], dtype=numpy.int64))
listoffsetarray = awkward1.layout.ListOffsetArray64(offsets, indexedarray)
assert awkward1.tolist(listoffsetarray) == [[2.2, 2.2, 0.0], [],
[3.3, 4.4]]
assert awkward1.tolist(listoffsetarray[::-1]) == [[3.3, 4.4], [],
[2.2, 2.2, 0.0]]
assert awkward1.tolist(listoffsetarray[[2, 0]]) == [[3.3, 4.4],
[2.2, 2.2, 0.0]]
assert awkward1.tolist(listoffsetarray[[2, 0],
1]) == [4.4, 2.2] # invokes carry
assert awkward1.tolist(listoffsetarray[2:, 1]) == [4.4] # invokes carry
index = awkward1.layout.Index64(
numpy.array([2, 2, 0, 3, -1], dtype=numpy.int64))
indexedarray = awkward1.layout.IndexedOptionArray64(index, content)
listoffsetarray = awkward1.layout.ListOffsetArray64(offsets, indexedarray)
assert awkward1.tolist(listoffsetarray) == [[2.2, 2.2, 0.0], [],
[3.3, None]]
assert awkward1.tolist(listoffsetarray[::-1]) == [[3.3, None], [],
[2.2, 2.2, 0.0]]
assert awkward1.tolist(listoffsetarray[[2, 0]]) == [[3.3, None],
[2.2, 2.2, 0.0]]
assert awkward1.tolist(listoffsetarray[[2, 0],
1]) == [None, 2.2] # invokes carry
assert awkward1.tolist(listoffsetarray[2:, 1]) == [None] # invokes carry
def test_listoffsetarray_at():
array1 = awkward1.layout.ListOffsetArrayU32(offsets1, content)
array2 = awkward1.layout.ListOffsetArrayU32(offsets2, array1)
assert awkward1.tolist(array1[2,]) == [4.4, 5.5]
assert awkward1.tolist(array1[2, 1:]) == [5.5]
assert awkward1.tolist(array1[2:, 0]) == [4.4, 6.6, 7.7]
assert awkward1.tolist(array1[2:, -1]) == [5.5, 6.6, 9.9]
def test():
out = awkward1.FillableArray()
out.beginrecord()
if True:
out.field("x"); out.integer(3)
out.field("extreme"); out.beginrecord()
if True:
out.field("pt"); out.real(3.3)
out.field("charge"); out.integer(-1)
out.field("iso"); out.integer(100)
out.endrecord()
out.endrecord()
out.beginrecord()
if True:
out.field("x"); out.integer(3)
out.endrecord()
ss = out.snapshot()
assert awkward1.tolist(ss) == [{"x": 3, "extreme": {"pt": 3.3, "charge": -1, "iso": 100}}, {"x": 3, "extreme": None}]
assert awkward1.tolist(awkward1.Array([{"x": 3, "extreme": {"pt": 3.3, "charge": -1, "iso": 100}}, {"x": 3}])) == [{"x": 3, "extreme": {"pt": 3.3, "charge": -1, "iso": 100}}, {"x": 3, "extreme": None}]
assert awkward1.tolist(awkward1.Array([{"x": 3, "extreme": {"pt": 3.3, "charge": -1, "iso": 100}}, {"x": 3, "what": 3}])) == [{"x": 3, "extreme": {"pt": 3.3, "charge": -1, "iso": 100}, "what": None}, {"x": 3, "extreme": None, "what": 3}]
def test_field_names():
array = awkward1.Array([[{
"x": 1.1,
"y": [1],
"z": "one"
}, {
"x": 2.2,
"y": [2, 2],
"z": "two"
}, {
"x": 3.3,
"y": [3, 3, 3],
"z": "three"
}], [],
[{
"x": 4.4,
"y": [4, 4, 4, 4],
"z": "four"
}, {
"x": 5.5,
"y": [5, 5, 5, 5, 5],
"z": "five"
}]])
assert "x" in dir(array)
assert "y" in dir(array)
assert "z" in dir(array)
assert awkward1.tolist(array.x) == [[1.1, 2.2, 3.3], [], [4.4, 5.5]]
assert awkward1.tolist(array.y) == [[[1], [2, 2], [3, 3, 3]], [],
[[4, 4, 4, 4], [5, 5, 5, 5, 5]]]
assert awkward1.tolist(array.z) == [["one", "two", "three"], [],
["four", "five"]]
def test_listoffsetarray_array_slice():
array1 = awkward1.layout.ListOffsetArray64(offsets1, content)
array2 = awkward1.layout.ListOffsetArray64(offsets2, array1)
assert awkward1.tolist(array2[[0, 0, 1, 1,
1, 0]]) == [[[1.1, 2.2, 3.3], []],
[[1.1, 2.2, 3.3], []],
[[4.4, 5.5]], [[4.4, 5.5]],
[[4.4, 5.5]],
[[1.1, 2.2, 3.3], []]]
assert awkward1.tolist(array2[[0, 0, 1, 1, 1, 0], :]) == [[[1.1, 2.2, 3.3],
[]],
[[1.1, 2.2, 3.3],
[]],
[[4.4, 5.5]],
[[4.4, 5.5]],
[[4.4, 5.5]],
[[1.1, 2.2, 3.3],
[]]]
assert awkward1.tolist(array2[[0, 0, 1, 1, 1, 0], :, 1:]) == [[[2.2, 3.3],
[]],
[[2.2, 3.3],
[]],
[[5.5]],
[[5.5]],
[[5.5]],
[[2.2, 3.3],
[]]]
def test_unknown():
a = awkward1.fromjson("[[], [], []]").layout
assert awkward1.tolist(a) == [[], [], []]
assert str(awkward1.typeof(a)) == "var * unknown"
assert awkward1.typeof(a) == awkward1.layout.ListType(awkward1.layout.UnknownType())
assert not awkward1.typeof(a) == awkward1.layout.PrimitiveType("float64")
a = awkward1.fromjson("[[], [[], []], [[], [], []]]").layout
assert awkward1.tolist(a) == [[], [[], []], [[], [], []]]
assert str(awkward1.typeof(a)) == "var * var * unknown"
assert awkward1.typeof(a) == awkward1.layout.ListType(awkward1.layout.ListType(awkward1.layout.UnknownType()))
a = awkward1.layout.FillableArray()
a.beginlist()
a.endlist()
a.beginlist()
a.endlist()
a.beginlist()
a.endlist()
assert awkward1.tolist(a) == [[], [], []]
assert str(awkward1.typeof(a)) == "var * unknown"
assert awkward1.typeof(a) == awkward1.layout.ListType(awkward1.layout.UnknownType())
assert not awkward1.typeof(a) == awkward1.layout.PrimitiveType("float64")
a = a.snapshot()
assert awkward1.tolist(a) == [[], [], []]
assert str(awkward1.typeof(a)) == "var * unknown"
assert awkward1.typeof(a) == awkward1.layout.ListType(awkward1.layout.UnknownType())
assert not awkward1.typeof(a) == awkward1.layout.PrimitiveType("float64")
def test_unionarray():
one0 = awkward1.layout.NumpyArray(
numpy.array([0.0, 1.1, 2.2, 3.3], dtype=numpy.float64))
one1 = awkward1.layout.NumpyArray(numpy.array([4, 5], dtype=numpy.int64))
onetags = awkward1.layout.Index8(
numpy.array([0, 0, 0, 0, 1, 1], dtype=numpy.int8))
oneindex = awkward1.layout.Index64(
numpy.array([0, 1, 2, 3, 0, 1], dtype=numpy.int64))
one = awkward1.Array(
awkward1.layout.UnionArray8_64(onetags, oneindex, [one0, one1]))
two0 = awkward1.layout.NumpyArray(numpy.array([0, 100], dtype=numpy.int64))
two1 = awkward1.layout.NumpyArray(
numpy.array([200.3, 300.3, 400.4, 500.5], dtype=numpy.float64))
twotags = awkward1.layout.Index8(
numpy.array([0, 0, 1, 1, 1, 1], dtype=numpy.int8))
twoindex = awkward1.layout.Index64(
numpy.array([0, 1, 0, 1, 2, 3], dtype=numpy.int64))
two = awkward1.Array(
awkward1.layout.UnionArray8_64(twotags, twoindex, [two0, two1]))
assert awkward1.tolist(one) == [0.0, 1.1, 2.2, 3.3, 4, 5]
assert awkward1.tolist(two) == [0, 100, 200.3, 300.3, 400.4, 500.5]
assert awkward1.tolist(one +
two) == [0.0, 101.1, 202.5, 303.6, 404.4, 505.5]
def test_listoffsetarray_slice():
array1 = awkward1.layout.ListOffsetArrayU32(offsets1, content)
array2 = awkward1.layout.ListOffsetArrayU32(offsets2, array1)
assert awkward1.tolist(array1[1:-1]) == [[], [4.4, 5.5], [6.6]]
assert awkward1.tolist(array1[1:-1,]) == [[], [4.4, 5.5], [6.6]]
assert awkward1.tolist(array2[1:-1]) == [[[4.4, 5.5]], []]
assert awkward1.tolist(array2[1:-1,]) == [[[4.4, 5.5]], []]
def test_getitem_array_U32():
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]))
listarray = awkward1.layout.ListArrayU32(awkward1.layout.IndexU32(numpy.array([0, 3, 3, 5, 6], numpy.uint32)), awkward1.layout.IndexU32(numpy.array([3, 3, 5, 6, 10], numpy.uint32)), content)
@numba.njit
def f1(q):
return q[[2, 0, 0, 1]]
assert awkward1.tolist(f1(listarray)) == [[3.3, 4.4], [0.0, 1.1, 2.2], [0.0, 1.1, 2.2], []]
@numba.njit
def f2(q):
return q[[2, 0, 0, -1], 1]
assert awkward1.tolist(f2(listarray)) == [4.4, 1.1, 1.1, 7.7]
@numba.njit
def f3(q):
return q[[2, 0, 0, -1], [-1, -1, 0, 0]]
assert awkward1.tolist(f3(listarray)) == [4.4, 2.2, 0.0, 6.6]
listarray.setidentities()
assert numpy.asarray(f1(listarray).identities).tolist() == [[2], [0], [0], [1]]
assert numpy.asarray(f2(listarray).identities).tolist() == [[2, 1], [0, 1], [0, 1], [4, 1]]
assert numpy.asarray(f3(listarray).identities).tolist() == [[2, 1], [0, 2], [0, 0], [4, 0]]
def test_boxing():
@numba.njit
def f1(q):
return 3.14
assert f1(recordarray) == 3.14
assert f1(recordarray[2]) == 3.14
@numba.njit
def f2(q):
return q
assert awkward1.tolist(f2(recordarray)) == [{
"one": 1,
"two": [1.1, 2.2, 3.3]
}, {
"one": 2,
"two": []
}, {
"one": 3,
"two": [4.4, 5.5]
}, {
"one": 4,
"two": [6.6]
}, {
"one": 5,
"two": [7.7, 8.8, 9.9]
}]
assert awkward1.tolist(f2(recordarray[2])) == {"one": 3, "two": [4.4, 5.5]}
def test_listoffsetarrayA32():
for depth in 0, 1, 2, 3:
for cuts in itertools.permutations((0, 1, 4, -5), depth):
assert awkward1.tolist(modelA[cuts]) == awkward1.tolist(listoffsetarrayA32[cuts])
for depth in 0, 1, 2, 3:
for cuts in itertools.permutations((slice(None), slice(1, None), slice(None, -1), slice(None, None, 2)), depth):
assert awkward1.tolist(modelA[cuts]) == awkward1.tolist(listoffsetarrayA32[cuts])
for depth in 0, 1, 2, 3:
for cuts in itertools.permutations((slice(1, None), slice(None, -1), 2, -2), depth):
assert awkward1.tolist(modelA[cuts]) == awkward1.tolist(listoffsetarrayA32[cuts])
for depth in 0, 1, 2, 3:
for cuts in itertools.permutations(([2, 0, 0, 1], [1, -2, 0, -1], 2, -2), depth):
assert awkward1.tolist(modelA[cuts]) == awkward1.tolist(listoffsetarrayA32[cuts])
for depth in 0, 1, 2, 3:
for cuts in itertools.permutations(([2, 0, 0, 1], [1, -2, 0, -1], slice(1, None), slice(None, -1)), depth):
cuts = cuts
while len(cuts) > 0 and isinstance(cuts[0], slice):
cuts = cuts[1:]
while len(cuts) > 0 and isinstance(cuts[-1], slice):
cuts = cuts[:-1]
if any(isinstance(x, slice) for x in cuts):
continue
assert awkward1.tolist(modelA[cuts]) == awkward1.tolist(listoffsetarrayA32[cuts])
def test_newaxis():
array = numpy.arange(2 * 3 * 5).reshape(2, 3, 5)
numpyarray = awkward1.layout.NumpyArray(array)
content = awkward1.layout.NumpyArray(array.reshape(-1))
inneroffsets = awkward1.layout.Index64(
numpy.array([0, 5, 10, 15, 20, 25, 30]))
outeroffsets = awkward1.layout.Index64(numpy.array([0, 3, 6]))
listoffsetarray = awkward1.layout.ListOffsetArray64(
outeroffsets, awkward1.layout.ListOffsetArray64(inneroffsets, content))
assert awkward1.tolist(array[:,
numpy.newaxis]) == [[[[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.tolist(
listoffsetarray[:, numpy.newaxis]) == [[[[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]]]]
def test_listarray_slice():
array1 = awkward1.layout.ListArray64(starts1, stops1, content)
array2 = awkward1.layout.ListArray64(starts2, stops2, array1)
assert awkward1.tolist(array1[1:-1]) == [[], [4.4, 5.5], [6.6]]
assert awkward1.tolist(array1[1:-1, ]) == [[], [4.4, 5.5], [6.6]]
assert awkward1.tolist(array2[1:-1]) == [[[4.4, 5.5]], []]
assert awkward1.tolist(array2[1:-1, ]) == [[[4.4, 5.5]], []]
def test_listarray_at():
array1 = awkward1.layout.ListArray64(starts1, stops1, content)
array2 = awkward1.layout.ListArray64(starts2, stops2, array1)
assert awkward1.tolist(array1[2]) == [4.4, 5.5]
assert awkward1.tolist(array1[2, ]) == [4.4, 5.5]
assert awkward1.tolist(array1[2, 1:]) == [5.5]
assert awkward1.tolist(array1[2:, 0]) == [4.4, 6.6, 7.7]
assert awkward1.tolist(array1[2:, -1]) == [5.5, 6.6, 9.9]
def test_fillable_tuple():
fillable = awkward1.layout.FillableArray()
assert str(fillable.type) == 'unknown'
assert awkward1.tolist(fillable.snapshot()) == []
fillable.begintuple(0)
fillable.endtuple()
fillable.begintuple(0)
fillable.endtuple()
fillable.begintuple(0)
fillable.endtuple()
assert str(fillable.type) == '()'
assert awkward1.tolist(fillable.snapshot()) == [(), (), ()]
fillable = awkward1.layout.FillableArray()
fillable.begintuple(3)
fillable.index(0)
fillable.boolean(True)
fillable.index(1)
fillable.beginlist()
fillable.integer(1)
fillable.endlist()
fillable.index(2)
fillable.real(1.1)
fillable.endtuple()
fillable.begintuple(3)
fillable.index(1)
fillable.beginlist()
fillable.integer(2)
fillable.integer(2)
fillable.endlist()
fillable.index(2)
fillable.real(2.2)
fillable.index(0)
fillable.boolean(False)
fillable.endtuple()
fillable.begintuple(3)
fillable.index(2)
fillable.real(3.3)
fillable.index(1)
fillable.beginlist()
fillable.integer(3)
fillable.integer(3)
fillable.integer(3)
fillable.endlist()
fillable.index(0)
fillable.boolean(True)
fillable.endtuple()
assert str(fillable.type) == '(bool, var * int64, float64)'
assert awkward1.tolist(fillable.snapshot()) == [(True, [1], 1.1), (False, [2, 2], 2.2), (True, [3, 3, 3], 3.3)]
def test_getitem_next():
@numba.njit
def f1(q):
return q[-4:, :]
assert awkward1.tolist(f1(indexedarray3)) == [[], [5.5], [5.5],
[6.6, 7.7, 8.8, 9.9]]
assert awkward1.tolist(
f1(indexedarray4)) == [None, [5.5], [5.5], [6.6, 7.7, 8.8, 9.9]]
def test_listoffsetarray_ellipsis():
array1 = awkward1.layout.ListOffsetArray64(offsets1, content)
array2 = awkward1.layout.ListOffsetArray64(offsets2, array1)
if not py27:
assert awkward1.tolist(array1[Ellipsis, 1:]) == [[2.2, 3.3], [], [5.5],
[], [8.8, 9.9]]
assert awkward1.tolist(array2[Ellipsis, 1:]) == [[[2.2, 3.3], []],
[[5.5]], [],
[[], [8.8, 9.9]]]
def test_boxing():
assert awkward1.tolist(array) == [[0.0, 1.1, 2.2], [], [3.3, 4.4], [5.5],
[6.6, 7.7, 8.8, 9.9]]
@numba.njit
def f1(q):
return q
assert awkward1.tolist(f1(array)) == [[0.0, 1.1, 2.2], [], [3.3, 4.4],
[5.5], [6.6, 7.7, 8.8, 9.9]]
def test_records():
array = awkward1.Array([[{
"x": 1,
"y": 1.1
}, {
"x": 2,
"y": 2.2
}, {
"x": 3,
"y": 3.3
}], [], [{
"x": 4,
"y": 4.4
}, {
"x": 5,
"y": 5.5
}], [{
"x": 100,
"y": 200
}]])
record = array[-1, -1]
assert awkward1.tolist(array[0] + record) == [{
"x": 101,
"y": 201.1
}, {
"x": 102,
"y": 202.2
}, {
"x": 103,
"y": 203.3
}]
assert awkward1.tolist(array + record) == [[{
"x": 101,
"y": 201.1
}, {
"x": 102,
"y": 202.2
}, {
"x": 103,
"y": 203.3
}], [], [{
"x": 104,
"y": 204.4
}, {
"x": 105,
"y": 205.5
}], [{
"x": 200,
"y": 400.0
}]]
assert awkward1.tolist(record + record) == {"x": 200, "y": 400}
def test_carry():
@numba.njit
def f1(q):
return q[-4:, ]
assert awkward1.tolist(f1(indexedarray1)) == [3.3, 0.0, 4.4, 8.8]
assert awkward1.tolist(f1(indexedarray2)) == [3.3, None, None, 8.8]
assert awkward1.tolist(f1(indexedarray3)) == [[], [5.5], [5.5],
[6.6, 7.7, 8.8, 9.9]]
assert awkward1.tolist(
f1(indexedarray4)) == [None, [5.5], [5.5], [6.6, 7.7, 8.8, 9.9]]
def test_tuple_ids():
array = awkward1.Array([[(1.1, [1], "one"), (2.2, [2, 2], "two"),
(3.3, [3, 3, 3], "three")], [],
[(4.4, [4, 4, 4, 4], "four"),
(5.5, [5, 5, 5, 5, 5], "five")]])
assert awkward1.tolist(array.i0) == [[1.1, 2.2, 3.3], [], [4.4, 5.5]]
assert awkward1.tolist(array.i1) == [[[1], [2, 2], [3, 3, 3]], [],
[[4, 4, 4, 4], [5, 5, 5, 5, 5]]]
assert awkward1.tolist(array.i2) == [["one", "two", "three"], [],
["four", "five"]]
def test_getitem_int():
@numba.njit
def f1(q, i):
return q[i]
assert f1(indexedarray1, 2) == 3.3
assert f1(indexedarray1, 3) == 0.0
assert f1(indexedarray2, 2) == 3.3
assert f1(indexedarray2, 3) == None
assert awkward1.tolist(f1(indexedarray3, 1)) == [0.0, 1.1, 2.2]
assert awkward1.tolist(f1(indexedarray4, 1)) == None
assert awkward1.tolist(f1(indexedarray4, 3)) == [5.5]
def test_missing():
content = awkward1.layout.NumpyArray(
numpy.array([[0.0, 0.0], [0.1, 1.0], [0.2, 2.0], [0.3, 3.0],
[0.4, 4.0], [0.5, 5.0]]))
index = awkward1.layout.Index64(
numpy.array([4, 0, 3, -1, 3], dtype=numpy.int64))
indexedarray = awkward1.layout.IndexedOptionArray64(index, content)
assert awkward1.tolist(indexedarray[3:, 0]) == [None, 0.3]
assert awkward1.tolist(indexedarray[3:, 1]) == [None, 3.0]
assert awkward1.tolist(indexedarray[3:, ::-1]) == [None, [3.0, 0.3]]
assert awkward1.tolist(indexedarray[3:,
[1, 1, 0]]) == [None, [3.0, 3.0, 0.3]]
def test_fromiter():
builder = awkward1.layout.FillableArray()
builder.integer(0)
builder.integer(1)
builder.integer(2)
builder.beginlist()
builder.endlist()
builder.beginlist()
builder.real(1.1)
builder.endlist()
builder.beginlist()
builder.real(1.1)
builder.real(2.2)
builder.endlist()
builder.beginlist()
builder.real(1.1)
builder.real(2.2)
builder.real(3.3)
builder.endlist()
assert awkward1.tolist(builder.snapshot()) == [
0, 1, 2, [], [1.1], [1.1, 2.2], [1.1, 2.2, 3.3]
]
assert awkward1.tolist(
awkward1.fromiter(
[0, 1, 2, [], [1.1], [1.1, 2.2],
[1.1, 2.2,
3.3]])) == [0, 1, 2, [], [1.1], [1.1, 2.2], [1.1, 2.2, 3.3]]
assert awkward1.tolist(
awkward1.fromiter([
0, 1, 2, [], "zero", [1.1], "one", [1.1, 2.2], "two",
[1.1, 2.2, 3.3], "three"
])) == [
0, 1, 2, [], "zero", [1.1], "one", [1.1, 2.2], "two",
[1.1, 2.2, 3.3], "three"
]
assert awkward1.tolist(
awkward1.fromjson(
'[0, 1, 2, [], "zero", [1.1], "one", [1.1, 2.2], "two", [1.1, 2.2, 3.3], "three"]'
)) == [
0, 1, 2, [], "zero", [1.1], "one", [1.1, 2.2], "two",
[1.1, 2.2, 3.3], "three"
]
assert awkward1.tojson(
awkward1.fromjson(
'[0,1,2,[],"zero",[1.1],"one",[1.1,2.2],"two",[1.1,2.2,3.3],"three"]'
)
) == '[0,1,2,[],"zero",[1.1],"one",[1.1,2.2],"two",[1.1,2.2,3.3],"three"]'
def test_flatten():
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], dtype=numpy.int64))
array = awkward1.layout.ListOffsetArray64(offsets, content)
assert awkward1.tolist(array) == [[0.0, 1.1, 2.2], [], [3.3, 4.4], [5.5],
[6.6, 7.7, 8.8, 9.9]]
assert awkward1.tolist(
array.flatten()) == [0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]
array2 = array[2:-1]
assert awkward1.tolist(array2.flatten()) == [3.3, 4.4, 5.5]
def test_getitem():
a = awkward1.fromjson("[[], [[], []], [[], [], []]]")
assert awkward1.tolist(a[2]) == [[], [], []]
assert awkward1.tolist(a[2, 1]) == []
with pytest.raises(ValueError) as excinfo:
a[2, 1, 0]
assert str(excinfo.value) == "in ListArray64 attempting to get 0, index out of range"
assert awkward1.tolist(a[2, 1][()]) == []
with pytest.raises(ValueError) as excinfo:
a[2, 1][0]
assert str(excinfo.value) == "in EmptyArray attempting to get 0, index out of range"
assert awkward1.tolist(a[2, 1][100:200]) == []
assert awkward1.tolist(a[2, 1, 100:200]) == []
assert awkward1.tolist(a[2, 1][numpy.array([], dtype=int)]) == []
assert awkward1.tolist(a[2, 1, numpy.array([], dtype=int)]) == []
with pytest.raises(ValueError) as excinfo:
a[2, 1, numpy.array([0], dtype=int)]
assert str(excinfo.value) == "in ListArray64 attempting to get 0, index out of range"
with pytest.raises(ValueError) as excinfo:
a[2, 1][100:200, 0]
assert str(excinfo.value) == "in EmptyArray, too many dimensions in slice"
with pytest.raises(ValueError) as excinfo:
a[2, 1][100:200, 200:300]
assert str(excinfo.value) == "in EmptyArray, too many dimensions in slice"
with pytest.raises(ValueError) as excinfo:
a[2, 1][100:200, numpy.array([], dtype=int)]
assert str(excinfo.value) == "in EmptyArray, too many dimensions in slice"
assert awkward1.tolist(a[1:, 1:]) == [[[]], [[], []]]
with pytest.raises(ValueError) as excinfo:
a[1:, 1:, 0]
assert str(excinfo.value) == "in ListArray64 attempting to get 0, index out of range"
def test_indexedoptionarray():
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]))
index1 = awkward1.layout.Index64(
numpy.array([2, -1, 4, 0, 8], dtype=numpy.int64))
index2 = awkward1.layout.Index64(
numpy.array([-1, 4, 4, -1, 0], dtype=numpy.int64))
one = awkward1.Array(awkward1.layout.IndexedOptionArray64(index1, content))
two = awkward1.Array(awkward1.layout.IndexedOptionArray64(index2, content))
assert awkward1.tolist(one + two) == [None, None, 8.8, None, 8.8]
uno = awkward1.layout.NumpyArray(numpy.array([2.2, 4.4, 4.4, 0.0, 8.8]))
dos = awkward1.layout.NumpyArray(numpy.array([6.6, 4.4, 4.4, 8.8, 0.0]))
assert awkward1.tolist(uno + two) == [None, 8.8, 8.8, None, 8.8]
assert awkward1.tolist(one + dos) == [8.8, None, 8.8, 8.8, 8.8]
def test_where():
one = awkward1.Array([0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9])
two = awkward1.Array([0, 100, 200, 300, 400, 500, 600, 700, 800, 900])
condition = awkward1.Array(
[False, False, False, False, False, True, False, True, False, True])
assert isinstance(awkward1.where(condition)[0], awkward1.Array)
assert awkward1.tolist(awkward1.where(condition)[0]) == [5, 7, 9]
assert awkward1.tolist(awkward1.where(condition, one,
two)) == awkward1.tolist(
numpy.where(
numpy.asarray(condition),
numpy.asarray(one),
numpy.asarray(two)))
def test_recordarray():
one = awkward1.Array([{
"x": 0,
"y": []
}, {
"x": 1,
"y": [1.1]
}, {
"x": 2,
"y": [1.1, 2.2]
}])
two = awkward1.Array([{
"x": 0,
"y": []
}, {
"x": 100,
"y": [100]
}, {
"x": 1000,
"y": [1000, 2000]
}])
assert awkward1.tolist(one + two) == [{
"x": 0,
"y": []
}, {
"x": 101,
"y": [101.1]
}, {
"x": 1002,
"y": [1001.1, 2002.2]
}]
def test_array():
@numba.njit
def f1(q):
return q[[2, 0, 0, 1], ]
assert awkward1.tolist(f1(array)) == [[3.3, 4.4], [0.0, 1.1, 2.2],
[0.0, 1.1, 2.2], []]
