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