def test_double_jagged(): array = awkward1.Array([[[0, 1, 2, 3], [4, 5]], [[6, 7, 8], [9, 10, 11, 12, 13]]], check_valid=True) assert awkward1.to_list(array[awkward1.Array([[[2, 1, 0], [-1]], [[-1, -2, -3], [2, 1, 1, 3]]], check_valid=True)]) == [[[2, 1, 0], [5]], [[8, 7, 6], [11, 10, 10, 12]]] content = awkward1.from_iter([[0, 1, 2, 3], [4, 5], [6, 7, 8], [9, 10, 11, 12, 13]], highlevel=False) regulararray = awkward1.layout.RegularArray(content, 2) assert awkward1.to_list(regulararray[:, awkward1.Array([[2, 1, 0], [-1]], check_valid=True)]) == [[[2, 1, 0], [5]], [[8, 7, 6], [13]]] assert awkward1.to_list(regulararray[1:, awkward1.Array([[2, 1, 0], [-1]], check_valid=True)]) == [[[8, 7, 6], [13]]] offsets = awkward1.layout.Index64(numpy.array([0, 2, 4], dtype=numpy.int64)) listoffsetarray = awkward1.layout.ListOffsetArray64(offsets, content) assert awkward1.to_list(listoffsetarray[:, awkward1.Array([[2, 1, 0], [-1]], check_valid=True)]) == [[[2, 1, 0], [5]], [[8, 7, 6], [13]]] assert awkward1.to_list(listoffsetarray[1:, awkward1.Array([[2, 1, 0], [-1]], check_valid=True)]) == [[[8, 7, 6], [13]]]
def test_Record_getitem(): record = awkward1.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] }], check_valid=True)[3] @numba.njit def f1(x): return x["x"] assert f1(record) == 3.3 @numba.njit def f2(x): return x["y"] assert awkward1.to_list(f2(record)) == [3, 3, 3] @numba.njit def f3(x): return x.x assert f3(record) == 3.3 @numba.njit def f4(x): return x.y assert awkward1.to_list(f4(record)) == [3, 3, 3]
def test_RecordArray_getitem_field(): array = awkward1.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] }], check_valid=True) @numba.njit def f1(x): return x[1:4]["x"] assert awkward1.to_list(f1(array)) == [1.1, 2.2, 3.3] @numba.njit def f2(x): return x[1:4]["y"] assert awkward1.to_list(f2(array)) == [[1], [2, 2], [3, 3, 3]] @numba.njit def f3(x): return x[1:4].x assert awkward1.to_list(f3(array)) == [1.1, 2.2, 3.3] @numba.njit def f4(x): return x[1:4].y assert awkward1.to_list(f4(array)) == [[1], [2, 2], [3, 3, 3]]
def test_numpyarray(): layout = 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) numbatype = awkward1._connect._numba.arrayview.tonumbatype(layout.form) assert numba.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 f1(x): return x[5] assert f1(array) == 5.5 assert counter[0] == 1 assert f1(array) == 5.5 assert counter[0] == 1
def test_ArrayBuilder_append_numba3(): @numba.njit def f1(array, builder): builder.extend(array[3]) builder.extend(array[2]) builder.extend(array[2]) builder.extend(array[0]) builder.extend(array[1]) builder.extend(array[-1]) 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) builder = awkward1.ArrayBuilder() f1(array, builder) assert awkward1.to_list(builder.snapshot()) == [ 5.5, 3.3, 4.4, 3.3, 4.4, 0.0, 1.1, 2.2, 6.6, 7.7, 8.8, 9.9 ]
def test_ListArray_getitem(): 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) @numba.njit def f1(x, i): return x[i] assert awkward1.to_list(f1(array, 0)) == [0.0, 1.1, 2.2] assert awkward1.to_list(f1(array, 1)) == [] assert awkward1.to_list(f1(array, 2)) == [3.3, 4.4] assert awkward1.to_list(f1(array, 3)) == [5.5] assert awkward1.to_list(f1(array, 4)) == [6.6, 7.7, 8.8, 9.9] @numba.njit def f2(x, i1, i2): return x[i1:i2] assert awkward1.to_list(f2(array, 1, 4)) == [[], [3.3, 4.4], [5.5]]
def test_list_array(): array = awkward1.Array(numpy.arange(3*5*2).reshape(3, 5, 2).tolist()) assert awkward1.num(array, axis=0) == 3 assert awkward1.num(array, axis=1) == [5, 5, 5] assert awkward1.num(array, axis=2) == [[2, 2, 2, 2, 2], [2, 2, 2, 2, 2], [2, 2, 2, 2, 2]] with pytest.raises(ValueError) as err: assert awkward1.num(array, axis=3) assert str(err.value) == "'axis' out of range for 'num'" assert awkward1.num(array, axis=-1) == [5, 5, 5] assert awkward1.num(array, axis=-2) == [[2, 2, 2, 2, 2], [2, 2, 2, 2, 2], [2, 2, 2, 2, 2]] assert awkward1.num(array, axis=-3) == 3 with pytest.raises(ValueError) as err: assert awkward1.num(array, axis=-4) assert str(err.value) == "axis == -4 exceeds the depth == 3 of this array"
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(): array = awkward1.Array([{ "x": "one" }, { "x": "two" }, { "x": "three" }], check_valid=True) assert awkward1.to_list(array) == [{ "x": "one" }, { "x": "two" }, { "x": "three" }] assert awkward1.to_list(awkward1.from_iter(awkward1.to_list(array))) == [{ "x": "one" }, { "x": "two" }, { "x": "three" }] assert awkward1.to_list(array.layout) == [{ "x": "one" }, { "x": "two" }, { "x": "three" }] assert awkward1.to_list(awkward1.from_iter(awkward1.to_list( array.layout))) == [{ "x": "one" }, { "x": "two" }, { "x": "three" }]
def test_ListArray_deep_at(): content = awkward1.layout.NumpyArray( numpy.array([ 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.0, 11.1, 12.2, 13.3, 14.4, 15.5, 16.6, 17.7, 18.8, 19.9 ])) offsets1 = awkward1.layout.Index32( numpy.array([0, 2, 4, 6, 8, 10, 12, 14, 16, 18], dtype=numpy.int32)) listarray1 = awkward1.layout.ListOffsetArray32(offsets1, content) offsets2 = awkward1.layout.Index64( numpy.array([0, 2, 4, 6, 8], dtype=numpy.int64)) listarray2 = awkward1.layout.ListOffsetArray64(offsets2, listarray1) offsets3 = awkward1.layout.Index32( numpy.array([0, 2, 4], dtype=numpy.int32)) listarray3 = awkward1.layout.ListOffsetArray32(offsets3, listarray2) array = awkward1.Array(listarray3, check_valid=True) @numba.njit def f1(x): return x[1][1][1][1] assert f1(array) == 16.6 @numba.njit def f2(x): return x[1][1][1] assert awkward1.to_list(f2(array)) == [15.5, 16.6] @numba.njit def f3(x): return x[1][1] assert awkward1.to_list(f3(array)) == [[13.3, 14.4], [15.5, 16.6]] @numba.njit def f4(x): return x[1] assert awkward1.to_list(f4(array)) == [[[9.9, 10.0], [11.1, 12.2]], [[13.3, 14.4], [15.5, 16.6]]]
def test_nested_virtualness(): counter = [0, 0] 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])) def materialize1(): counter[1] += 1 return content generator1 = awkward1.layout.ArrayGenerator(materialize1, form=content.form, length=len(content)) virtual1 = awkward1.layout.VirtualArray(generator1) offsets = awkward1.layout.Index64( numpy.array([0, 3, 3, 5, 6, 10], dtype=numpy.int64)) listarray = awkward1.layout.ListOffsetArray64(offsets, virtual1) def materialize2(): counter[0] += 1 return listarray generator2 = awkward1.layout.ArrayGenerator(materialize2, form=listarray.form, length=len(listarray)) virtual2 = awkward1.layout.VirtualArray(generator2) array = awkward1.Array(virtual2) assert counter == [0, 0] @numba.njit def f1(x, i): return x[i] tmp1 = f1(array, 2) assert counter == [1, 0] tmp2 = f1(tmp1, 1) assert tmp2 == 4.4 assert counter == [1, 1]
def _apply_global_index(self, index): """Internal method to take from a collection using a flat index This is often necessary to be able to still resolve cross-references on reduced arrays or single records. """ if isinstance(index, int): out = self._content()[index] return awkward1.Record(out, behavior=self.behavior) def flat_take(layout): idx = awkward1.Array(layout) return self._content()[idx.mask[idx >= 0]] def descend(layout, depth): if layout.purelist_depth == 1: return lambda: flat_take(layout) (index, ) = awkward1.broadcast_arrays(index) out = awkward1._util.recursively_apply(index.layout, descend) return awkward1.Array(out, behavior=self.behavior)
def test_custom_record4(): behavior = {} behavior["__numba_typer__", "Dummy", operator.add, "Dummy"] = dummy_typer4 behavior["__numba_lower__", "Dummy", operator.add, "Dummy"] = dummy_lower4 behavior["__numba_typer__", "Dummy", operator.eq, "Dummy"] = dummy_typer4 behavior["__numba_lower__", "Dummy", operator.eq, "Dummy"] = dummy_lower4 array = awkward1.Array([{"x": 1.1, "y": 100}, {"x": 2.2, "y": 200}, {"x": 3.3, "y": 300}], behavior=behavior, check_valid=True) array.layout.setparameter("__record__", "Dummy") @numba.njit def f1(x, i, j): return x[i] + x[j] assert f1(array, 1, 2) == 5.5 @numba.njit def f2(x, i, j): return x[i] == x[j] assert f2(array, 1, 2) == 5.5
def test_ArrayBuilder_append_numba(): @numba.njit def f1(array, builder): builder.append(array, 3) builder.append(array, 2) builder.append(array, 2) builder.append(array, 0) builder.append(array, 1) builder.append(array, -1) 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) builder = awkward1.ArrayBuilder() f1(array, builder) assert awkward1.to_list(builder.snapshot()) == [[5.5], [3.3, 4.4], [3.3, 4.4], [0.0, 1.1, 2.2], [], [6.6, 7.7, 8.8, 9.9]]
def test_record_array_axis_out_of_range(): array = awkward1.Array([{ "x": [1], "y": [[], [1]] }, { "x": [1, 2], "y": [[], [1], [1, 2]] }, { "x": [1, 2, 3], "y": [[], [1], [1, 2], [1, 2, 3]] }]) with pytest.raises(ValueError) as err: assert awkward1.num(array, axis=-2) assert str(err.value).startswith( "axis == -2 exceeds the min depth == 2 of this array") with pytest.raises(ValueError) as err: assert awkward1.num(array, axis=-3) assert str(err.value).startswith( "axis == -3 exceeds the depth == 2 of this array")
def nestedindex(stack): """Concatenate a list of indices along a new axis Signature: index1,index2,...,!nestedindex Index arrays should all be same shape flat arrays Outputs a jagged array with same outer shape as index arrays """ indexers = stack[:] stack.clear() # return awkward1.concatenate([idx[:, None] for idx in indexers], axis=1) n = len(indexers) out = numpy.empty(n * len(indexers[0]), dtype="int64") for i, idx in enumerate(indexers): out[i::n] = idx offsets = numpy.arange(0, len(out) + 1, n, dtype=numpy.int64) out = awkward1.Array( awkward1.layout.ListOffsetArray64( awkward1.layout.Index64(offsets), awkward1.layout.NumpyArray(out), )) stack.append(out)
def test_repartition(): array = awkward1.Array([[], [1.1, 2.2, 3.3], [], [], [4.4, 5.5], [], [6.6], [7.7, 8.8, 9.9], []]) array2 = awkward1.repartition(array, 2) array3 = awkward1.repartition(array, 3) array4 = awkward1.repartition(array, [3, 2, 3, 1]) array5 = awkward1.repartition(array2, None) assert isinstance(array.layout, awkward1.layout.Content) assert isinstance(array2.layout, awkward1.partition.PartitionedArray) assert isinstance(array3.layout, awkward1.partition.PartitionedArray) assert isinstance(array4.layout, awkward1.partition.PartitionedArray) assert isinstance(array5.layout, awkward1.layout.Content) assert awkward1.to_list(array) == [[], [1.1, 2.2, 3.3], [], [], [4.4, 5.5], [], [6.6], [7.7, 8.8, 9.9], []] assert awkward1.to_list(array2) == [[], [1.1, 2.2, 3.3], [], [], [4.4, 5.5], [], [6.6], [7.7, 8.8, 9.9], []] assert awkward1.to_list(array3) == [[], [1.1, 2.2, 3.3], [], [], [4.4, 5.5], [], [6.6], [7.7, 8.8, 9.9], []] assert awkward1.to_list(array4) == [[], [1.1, 2.2, 3.3], [], [], [4.4, 5.5], [], [6.6], [7.7, 8.8, 9.9], []] assert awkward1.to_list(array5) == [[], [1.1, 2.2, 3.3], [], [], [4.4, 5.5], [], [6.6], [7.7, 8.8, 9.9], []] assert [awkward1.to_list(x) for x in array2.layout.partitions] == [[[], [1.1, 2.2, 3.3]], [[], []], [[4.4, 5.5], []], [[6.6], [7.7, 8.8, 9.9]], [[]]] assert [awkward1.to_list(x) for x in array3.layout.partitions] == [[[], [1.1, 2.2, 3.3], []], [[], [4.4, 5.5], []], [[6.6], [7.7, 8.8, 9.9], []]] assert [awkward1.to_list(x) for x in array4.layout.partitions] == [[[], [1.1, 2.2, 3.3], []], [[], [4.4, 5.5]], [[], [6.6], [7.7, 8.8, 9.9]], [[]]]
def test_0459(): 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.parameters(awkward1.concatenate([plain_plain, plain_plain])) == {} assert awkward1.parameters(awkward1.concatenate([array_plain, array_plain])) == {"__array__": "zoinks"} assert awkward1.parameters(awkward1.concatenate([plain_isdoc, plain_isdoc])) == {"__doc__": "This is a zoink."} assert awkward1.parameters(awkward1.concatenate([array_isdoc, array_isdoc])) == {"__array__": "zoinks", "__doc__": "This is a zoink."} assert isinstance(awkward1.concatenate([plain_plain, plain_plain]).layout, awkward1.layout.NumpyArray) assert isinstance(awkward1.concatenate([array_plain, array_plain]).layout, awkward1.layout.NumpyArray) assert isinstance(awkward1.concatenate([plain_isdoc, plain_isdoc]).layout, awkward1.layout.NumpyArray) assert isinstance(awkward1.concatenate([array_isdoc, array_isdoc]).layout, awkward1.layout.NumpyArray) assert awkward1.parameters(awkward1.concatenate([plain_plain, array_plain])) == {} assert awkward1.parameters(awkward1.concatenate([plain_isdoc, array_isdoc])) == {} assert awkward1.parameters(awkward1.concatenate([array_plain, plain_plain])) == {} assert awkward1.parameters(awkward1.concatenate([array_isdoc, plain_isdoc])) == {} assert isinstance(awkward1.concatenate([plain_plain, array_plain]).layout, awkward1.layout.UnionArray8_64) assert isinstance(awkward1.concatenate([plain_isdoc, array_isdoc]).layout, awkward1.layout.UnionArray8_64) assert isinstance(awkward1.concatenate([array_plain, plain_plain]).layout, awkward1.layout.UnionArray8_64) assert isinstance(awkward1.concatenate([array_isdoc, plain_isdoc]).layout, awkward1.layout.UnionArray8_64) assert awkward1.parameters(awkward1.concatenate([plain_plain, plain_isdoc])) == {} assert awkward1.parameters(awkward1.concatenate([array_plain, array_isdoc])) == {"__array__": "zoinks"} assert awkward1.parameters(awkward1.concatenate([plain_isdoc, plain_plain])) == {} assert awkward1.parameters(awkward1.concatenate([array_isdoc, array_plain])) == {"__array__": "zoinks"} assert isinstance(awkward1.concatenate([plain_plain, plain_isdoc]).layout, awkward1.layout.NumpyArray) assert isinstance(awkward1.concatenate([array_plain, array_isdoc]).layout, awkward1.layout.NumpyArray) assert isinstance(awkward1.concatenate([plain_isdoc, plain_plain]).layout, awkward1.layout.NumpyArray) assert isinstance(awkward1.concatenate([array_isdoc, array_plain]).layout, awkward1.layout.NumpyArray)
def test_IndexedArray_getitem(): 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([3, 2, 2, 5, 0, 7], dtype=numpy.int64)) array = awkward1.Array(awkward1.layout.IndexedArray64(index, content), check_valid=True) @numba.njit def f1(x, i): return x[i] assert [f1(array, 0), f1(array, 1), f1(array, 2), f1(array, 3)] == [3.3, 2.2, 2.2, 5.5] @numba.njit def f2(x, i1, i2): return x[i1:i2] assert awkward1.to_list(f2(array, 1, 5)) == [2.2, 2.2, 5.5, 0]
def test(): behavior = {} behavior["__typestr__", "Point"] = "P" behavior["Point"] = Point array = awkward1.Array([[{ "x": 1, "y": [1.1] }, { "x": 2, "y": [2.0, 0.2] }], [], [{ "x": 3, "y": [3.0, 0.3, 3.3] }]], with_name="Point", behavior=behavior, check_valid=True) assert repr(array[0, 0]) == "<1 [1.1]>" assert repr(array[0]) == "<Array [<1 [1.1]>, <2 [2, 0.2]>] type='2 * P'>" assert repr( array ) == "<Array [[<1 [1.1]>, ... <3 [3, 0.3, 3.3]>]] type='3 * var * P'>"
def test_size(): assert awkward1.size(awkward1.Array([1.1, 2.2, 3.3, 4.4, 5.5], check_valid=True)) == 5 assert awkward1.size(awkward1.Array(numpy.arange(2*3*5).reshape(2, 3, 5), check_valid=True)) == 30 assert awkward1.size(awkward1.Array(numpy.arange(2*3*5).reshape(2, 3, 5), check_valid=True), 0) == 2 assert awkward1.size(awkward1.Array(numpy.arange(2*3*5).reshape(2, 3, 5), check_valid=True), 1) == 3 assert awkward1.size(awkward1.Array(numpy.arange(2*3*5).reshape(2, 3, 5), check_valid=True), 2) == 5 assert awkward1.size(awkward1.layout.NumpyArray(numpy.arange(2*3*5).reshape(2, 3, 5))) == 30 assert awkward1.size(awkward1.layout.NumpyArray(numpy.arange(2*3*5).reshape(2, 3, 5)), 0) == 2 assert awkward1.size(awkward1.layout.NumpyArray(numpy.arange(2*3*5).reshape(2, 3, 5)), 1) == 3 assert awkward1.size(awkward1.layout.NumpyArray(numpy.arange(2*3*5).reshape(2, 3, 5)), 2) == 5 assert numpy.size(numpy.arange(2*3*5).reshape(2, 3, 5)) == 30 assert numpy.size(numpy.arange(2*3*5).reshape(2, 3, 5), 0) == 2 assert numpy.size(numpy.arange(2*3*5).reshape(2, 3, 5), 1) == 3 assert numpy.size(numpy.arange(2*3*5).reshape(2, 3, 5), 2) == 5 with pytest.raises(ValueError) as err: awkward1.size(awkward1.Array(numpy.arange(2*3*5).reshape(2, 3, 5).tolist(), check_valid=True)) assert str(err.value).startswith("ak.size is ambiguous due to variable-length arrays (try ak.flatten to remove structure or ak.to_numpy to force regularity, if possible)")
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(): content = awkward1.Array([1, 2, 3, 4, 5]) generator1 = awkward1.layout.ArrayGenerator(lambda a, b: a * content + b, (100, ), {"b": 3}) assert awkward1.to_list(generator1()) == [103, 203, 303, 403, 503] assert generator1.args == (100, ) assert generator1.kwargs == {"b": 3} assert generator1.form is None assert generator1.length is None generator2 = generator1.with_args((1000, )) assert awkward1.to_list(generator2()) == [1003, 2003, 3003, 4003, 5003] assert generator2.args == (1000, ) assert generator2.kwargs == {"b": 3} assert generator2.form is None assert generator2.length is None generator3 = generator1.with_kwargs({"b": 4}) assert awkward1.to_list(generator3()) == [104, 204, 304, 404, 504] assert generator3.args == (100, ) assert generator3.kwargs == {"b": 4} assert generator3.form is None assert generator3.length is None generator4 = generator1.with_form(awkward1.forms.Form.fromjson('"int64"')) assert awkward1.to_list(generator4()) == [103, 203, 303, 403, 503] assert generator4.args == (100, ) assert generator4.kwargs == {"b": 3} assert json.loads(generator4.form.tojson()) == json.loads( awkward1.forms.Form.fromjson('"int64"').tojson()) assert generator4.length is None generator5 = generator1.with_length(5) assert awkward1.to_list(generator5()) == [103, 203, 303, 403, 503] assert generator5.args == (100, ) assert generator5.kwargs == {"b": 3} assert generator5.form is None assert generator5.length == 5
def test(): example = awkward1.Array([[{"x": 1, "y": []}, {"x": 2, "y": [1, 1]}], []]) cache = {} virtualarray = awkward1.virtual(lambda: example, form=example.layout.form, length=len(example)) assert len(cache) == 0 tmp1 = virtualarray["x"] assert json.loads(str(tmp1.layout.form)) == { "class": "VirtualArray", "form": { "class": "ListOffsetArray64", "offsets": "i64", "content": "int64" }, "has_length": True } assert len(cache) == 0 tmp2 = virtualarray["y"] assert json.loads(str(tmp2.layout.form)) == { "class": "VirtualArray", "form": { "class": "ListOffsetArray64", "offsets": "i64", "content": { "class": "ListOffsetArray64", "offsets": "i64", "content": "int64" } }, "has_length": True } assert len(cache) == 0 assert tmp1.tolist() == [[1, 2], []] assert tmp2.tolist() == [[[], [1, 1]], []]
def test_custom_record5(): behavior = {} behavior["__numba_typer__", abs, "Dummy"] = dummy_typer5 behavior["__numba_lower__", abs, "Dummy"] = dummy_lower5 behavior["__numba_typer__", operator.neg, "Dummy"] = dummy_typer5 behavior["__numba_lower__", operator.neg, "Dummy"] = dummy_lower5 array = awkward1.Array([{"x": 1.1, "y": 100}, {"x": -2.2, "y": 200}, {"x": 3.3, "y": 300}], behavior=behavior, check_valid=True) array.layout.setparameter("__record__", "Dummy") @numba.njit def f1(x, i): return abs(x[i]) assert f1(array, 1) == 2.2 assert f1(array, 2) == 3.3 @numba.njit def f2(x, i): return -x[i] assert f2(array, 1) == 2.2 assert f2(array, 2) == 3.3
def test_flat(): grad_tanh = awkward1.autograd.elementwise_grad(tanh) xs = awkward1.Array(numpy.linspace(-3, 3, 10), check_valid=True) assert awkward1.to_list(xs) == pytest.approx([ -3.0, -2.3333333333333335, -1.6666666666666667, -1.0, -0.3333333333333335, 0.33333333333333304, 1.0, 1.666666666666666, 2.333333333333333, 3.0 ]) assert awkward1.to_list(tanh(xs)) == pytest.approx([ -0.9950547536867305, -0.9813680813098666, -0.9311096086675776, -0.7615941559557649, -0.32151273753163445, 0.32151273753163406, 0.7615941559557649, 0.9311096086675775, 0.9813680813098666, 0.9950547536867306 ]) assert awkward1.to_list(grad_tanh(xs)) == pytest.approx([ 0.009866037165439843, 0.036916688986191167, 0.1330348966469106, 0.4199743416140259, 0.8966295596049142, 0.8966295596049146, 0.419974341614026, 0.13303489664691054, 0.03691668898619103, 0.009866037165440192 ])
def test_IndexedOptionArray_combinations(): content = awkward1.from_iter([[[0, 1, 2], [], [3, 4]], [], [[5]], [[6, 7, 8, 9]], [[], [10, 11, 12]]], highlevel=False) index = awkward1.layout.Index64( numpy.array([0, 1, -1, -1, 4], dtype=numpy.int64)) array = awkward1.Array(awkward1.layout.IndexedOptionArray64( index, content)) assert awkward1.to_list(array) == [[[0, 1, 2], [], [3, 4]], [], None, None, [[], [10, 11, 12]]] assert awkward1.to_list(awkward1.combinations(array, 2, axis=0)) == [ ([[0, 1, 2], [], [3, 4]], []), ([[0, 1, 2], [], [3, 4]], None), ([[0, 1, 2], [], [3, 4]], None), ([[0, 1, 2], [], [3, 4]], [[], [10, 11, 12]]), ([], None), ([], None), ([], [[], [10, 11, 12]]), (None, None), (None, [[], [10, 11, 12]]), (None, [[], [10, 11, 12]]) ] assert awkward1.to_list(awkward1.combinations(array, 2, axis=1)) == [[ ([0, 1, 2], []), ([0, 1, 2], [3, 4]), ([], [3, 4]) ], [], None, None, [([], [10, 11, 12])]] assert awkward1.to_list(awkward1.combinations(array, 2, axis=2)) == [[[ (0, 1), (0, 2), (1, 2) ], [], [(3, 4)]], [], None, None, [[], [(10, 11), (10, 12), (11, 12)]]]
def test_array_3d(): array = awkward1.Array(numpy.arange(3*5*2).reshape(3, 5, 2)) assert awkward1.to_list(array) == [[[ 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.num(array, axis=0) == 3 assert awkward1.to_list(awkward1.num(array, axis=1)) == [5, 5, 5] assert awkward1.to_list(awkward1.num(array, axis=2)) == [[2, 2, 2, 2, 2], [2, 2, 2, 2, 2], [2, 2, 2, 2, 2]] with pytest.raises(ValueError) as err: assert awkward1.num(array, axis=3) assert str(err.value) == "'axis' out of range for 'num'" assert awkward1.to_list(awkward1.num(array, axis=-1)) == [[2, 2, 2, 2, 2], [2, 2, 2, 2, 2], [2, 2, 2, 2, 2]] assert awkward1.to_list(awkward1.num(array, axis=-2)) == [5, 5, 5] assert awkward1.num(array, axis=-3) == 3 with pytest.raises(ValueError) as err: assert awkward1.num(array, axis=-4) assert str(err.value) == "axis == -4 exceeds the depth == 3 of this array"
def test_refcount(): array = awkward1.Array([1, 2, 3]) @numba.njit def f1(): array return 3.14 @numba.njit def f2(): array, array return 3.14 assert sys.getrefcount(array) == 2 f1() assert sys.getrefcount(array) == 3 f2() assert sys.getrefcount(array) == 5 del f1 assert sys.getrefcount(array) == 4 del f2 assert sys.getrefcount(array) == 2
def test_ByteMaskedArray_combinations(): content = awkward1.from_iter([[[0, 1, 2], [], [3, 4]], [], [[5]], [[6, 7, 8, 9]], [[], [10, 11, 12]]], 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, 1, 2], [], [3, 4]], [], None, None, [[], [10, 11, 12]]] assert awkward1.to_list(awkward1.combinations(array, 2, axis=0)) == [ ([[0, 1, 2], [], [3, 4]], []), ([[0, 1, 2], [], [3, 4]], None), ([[0, 1, 2], [], [3, 4]], None), ([[0, 1, 2], [], [3, 4]], [[], [10, 11, 12]]), ([], None), ([], None), ([], [[], [10, 11, 12]]), (None, None), (None, [[], [10, 11, 12]]), (None, [[], [10, 11, 12]]) ] assert awkward1.to_list(awkward1.combinations(array, 2, axis=1)) == [[ ([0, 1, 2], []), ([0, 1, 2], [3, 4]), ([], [3, 4]) ], [], None, None, [([], [10, 11, 12])]] assert awkward1.to_list(awkward1.combinations(array, 2, axis=2)) == [[[ (0, 1), (0, 2), (1, 2) ], [], [(3, 4)]], [], None, None, [[], [(10, 11), (10, 12), (11, 12)]]]