def test_tostring():
content = ak.layout.NumpyArray(np.arange(2 * 3 * 5 * 7).reshape(-1, 7))
offsetsA = np.arange(0, 2 * 3 * 5 + 5, 5)
offsetsB = np.arange(0, 2 * 3 + 3, 3)
startsA, stopsA = offsetsA[:-1], offsetsA[1:]
startsB, stopsB = offsetsB[:-1], offsetsB[1:]
listoffsetarrayA32 = ak.layout.ListOffsetArray32(
ak.layout.Index32(offsetsA), content)
listarrayA32 = ak.layout.ListArray32(ak.layout.Index32(startsA),
ak.layout.Index32(stopsA), content)
modelA = np.arange(2 * 3 * 5 * 7).reshape(2 * 3, 5, 7)
listoffsetarrayB32 = ak.layout.ListOffsetArray32(
ak.layout.Index32(offsetsB), listoffsetarrayA32)
listarrayB32 = ak.layout.ListArray32(ak.layout.Index32(startsB),
ak.layout.Index32(stopsB),
listarrayA32)
modelB = np.arange(2 * 3 * 5 * 7).reshape(2, 3, 5, 7)
assert content.tojson() == json.dumps(ak.to_list(content),
separators=(",", ":"))
assert listoffsetarrayA32.tojson() == json.dumps(modelA.tolist(),
separators=(",", ":"))
assert listoffsetarrayB32.tojson() == json.dumps(modelB.tolist(),
separators=(",", ":"))
ak.to_json(
ak.from_json("[[1.1,2.2,3],[],[4,5.5]]")) == "[[1.1,2.2,3],[],[4,5.5]]"
def test_tofile(tmp_path):
ak.to_json(
ak.from_json("[[1.1,2.2,3],[],[4,5.5]]"),
os.path.join(str(tmp_path), "tmp1.json"),
)
with open(os.path.join(str(tmp_path), "tmp1.json"), "r") as f:
f.read() == "[[1.1,2.2,3],[],[4,5.5]]"
def test_array_tojson():
# convert float 'nan' and 'inf' to user-defined strings
array = ak.layout.NumpyArray(
np.array([[float("nan"), float("nan"), 1.1],
[float("inf"), 3.3, float("-inf")]]))
assert (ak.to_json(array,
nan_string="NaN",
infinity_string="inf",
minus_infinity_string="-inf") ==
'[["NaN","NaN",1.1],["inf",3.3,"-inf"]]')
array2 = ak.Array([[0, 2], None, None, None, "NaN", "NaN"])
assert ak.to_json(array2,
nan_string="NaN") == '[[0,2],null,null,null,"NaN","NaN"]'
def test_builder_string():
builder = ak.ArrayBuilder()
builder.bytestring(b"one")
builder.bytestring(b"two")
builder.bytestring(b"three")
a = builder.snapshot()
assert str(a) == "[b'one', b'two', b'three']"
assert ak.to_list(a) == [b"one", b"two", b"three"]
assert ak.to_json(a) == '["one","two","three"]'
assert repr(a) == "<Array [b'one', b'two', b'three'] type='3 * bytes'>"
assert repr(ak.type(a)) == "3 * bytes"
builder = ak.ArrayBuilder()
builder.string("one")
builder.string("two")
builder.string("three")
a = builder.snapshot()
assert str(a) == "['one', 'two', 'three']"
assert ak.to_list(a) == ["one", "two", "three"]
assert ak.to_json(a) == '["one","two","three"]'
assert repr(a) == "<Array ['one', 'two', 'three'] type='3 * string'>"
assert repr(ak.type(a)) == "3 * string"
builder = ak.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()
assert str(a) == "[['one', 'two', 'three'], [], ['four', 'five']]"
assert ak.to_list(a) == [["one", "two", "three"], [], ["four", "five"]]
assert ak.to_json(a) == '[["one","two","three"],[],["four","five"]]'
assert repr(ak.type(a)) == "3 * var * string"
def test_scalar_record():
content1 = ak.layout.NumpyArray(np.array([1, 2, 3, 4, 5]))
content2 = ak.layout.NumpyArray(
np.array([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]))
offsets = ak.layout.Index64(np.array([0, 3, 3, 5, 6, 9]))
listoffsetarray = ak.layout.ListOffsetArray64(offsets, content2)
recordarray = ak.layout.RecordArray([content1, listoffsetarray],
keys=["one", "two"])
str(recordarray)
str(recordarray[2])
assert ak.to_json(recordarray[2]) == '{"one":3,"two":[4.4,5.5]}'
assert recordarray[2].keys() == ["one", "two"]
assert [ak.to_list(x) for x in recordarray[2].fields()] == [3, [4.4, 5.5]]
pairs = recordarray[2].fielditems()
assert pairs[0][0] == "one"
assert pairs[1][0] == "two"
assert pairs[0][1] == 3
assert ak.to_list(pairs[1][1]) == [4.4, 5.5]
assert ak.to_list(recordarray[2]) == {"one": 3, "two": [4.4, 5.5]}
assert ak.to_list(ak.layout.Record(recordarray, 2)) == {
"one": 3,
"two": [4.4, 5.5]
}
def test_json():
dataset = [
'[{"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}]',
]
for datum in dataset:
assert ak.to_json(ak.from_json(datum)) == datum
def generate():
start = stop = 0
while start < len(array):
stop = min(stop + events_per_basket, len(array))
chunk = json.loads(ak.to_json(array[start:stop]))
for x in chunk:
yield x
print(int(round(100 * stop / len(array))), "percent",
time.asctime(time.localtime()))
start = stop
def test_to_json():
# Complex numbers can't be converted to JSON without setting 'complex_record_fields',
# but the error messages should refer to that name now. (I changed the name at
# high-level, but not in the error messages emitted by C++ code.)
with pytest.raises(ValueError) as err:
ak.to_json(ak.from_iter([1 + 1j, 2 + 2j, 3 + 3j]))
assert "needs both" not in str(err)
expectation = [{
"r": 1.0,
"i": 1.0
}, {
"r": 2.0,
"i": 2.0
}, {
"r": 3.0,
"i": 3.0
}]
assert expectation == json.loads(
ak.to_json(ak.from_iter([1 + 1j, 2 + 2j, 3 + 3j]),
complex_record_fields=("r", "i")))
expectation = [
[{
"r": 1.0,
"i": 1.0
}, {
"r": 2.0,
"i": 2.0
}],
[],
[{
"r": 3.0,
"i": 3.0
}],
]
assert expectation == json.loads(
ak.to_json(
ak.from_iter([[1 + 1j, 2 + 2j], [], [3 + 3j]]),
complex_record_fields=("r", "i"),
))
def test_numpy():
a = ak.layout.NumpyArray(np.arange(2 * 3 * 5).reshape(2, 3, 5))
assert ak.to_list(a) == [
[[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 (
ak.to_json(a) ==
"[[[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]]]"
)
b = ak.layout.NumpyArray(
np.array([
[[1.1, 2.2, 3.3], [4.4, 5.5, 6.6]],
[[10.1, 20.2, 30.3], [40.4, 50.5, 60.6]],
]))
assert (
ak.to_json(b) ==
"[[[1.1,2.2,3.3],[4.4,5.5,6.6]],[[10.1,20.2,30.3],[40.4,50.5,60.6]]]")
c = ak.layout.NumpyArray(
np.array([[True, False, True], [False, False, True]]))
assert ak.to_json(c) == "[[true,false,true],[false,false,true]]"
def test_tostring():
# write a json string from an array built from
# multiple json fragments from a string
str = """{"x": 1.1, "y": []}
{"x": 2.2, "y": [1]}
{"x": 3.3, "y": [1, 2]}
{"x": 4.4, "y": [1, 2, 3]}
{"x": 5.5, "y": [1, 2, 3, 4]}
{"x": 6.6, "y": [1, 2, 3, 4, 5]}"""
array = ak.from_json(str)
assert ak.to_list(array) == [
{
"x": 1.1,
"y": []
},
{
"x": 2.2,
"y": [1]
},
{
"x": 3.3,
"y": [1, 2]
},
{
"x": 4.4,
"y": [1, 2, 3]
},
{
"x": 5.5,
"y": [1, 2, 3, 4]
},
{
"x": 6.6,
"y": [1, 2, 3, 4, 5]
},
]
assert (
ak.to_json(array) ==
'[{"x":1.1,"y":[]},{"x":2.2,"y":[1]},{"x":3.3,"y":[1,2]},{"x":4.4,"y":[1,2,3]},{"x":5.5,"y":[1,2,3,4]},{"x":6.6,"y":[1,2,3,4,5]}]'
)
def test_tojson():
assert (ak.to_json(regulararray) ==
"[[[0.0,1.1,2.2],[]],[[3.3,4.4],[5.5]],[[6.6,7.7,8.8,9.9],[]]]")
def test_basic():
content1 = ak.layout.NumpyArray(np.array([1, 2, 3, 4, 5]))
content2 = ak.layout.NumpyArray(
np.array([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]))
offsets = ak.layout.Index64(np.array([0, 3, 3, 5, 6, 9]))
listoffsetarray = ak.layout.ListOffsetArray64(offsets, content2)
recordarray = ak.layout.RecordArray(
[content1, listoffsetarray, content2, content1],
keys=["one", "two", "2", "wonky"],
)
assert ak.to_list(recordarray.field(0)) == [1, 2, 3, 4, 5]
assert ak.to_list(recordarray.field("two")) == [
[1.1, 2.2, 3.3],
[],
[4.4, 5.5],
[6.6],
[7.7, 8.8, 9.9],
]
assert ak.to_list(recordarray.field("wonky")) == [1, 2, 3, 4, 5]
str(recordarray)
assert (
ak.to_json(recordarray) ==
'[{"one":1,"two":[1.1,2.2,3.3],"2":1.1,"wonky":1},{"one":2,"two":[],"2":2.2,"wonky":2},{"one":3,"two":[4.4,5.5],"2":3.3,"wonky":3},{"one":4,"two":[6.6],"2":4.4,"wonky":4},{"one":5,"two":[7.7,8.8,9.9],"2":5.5,"wonky":5}]'
)
assert len(recordarray) == 5
assert recordarray.key(0) == "one"
assert recordarray.key(1) == "two"
assert recordarray.key(2) == "2"
assert recordarray.key(3) == "wonky"
assert recordarray.fieldindex("wonky") == 3
assert recordarray.fieldindex("one") == 0
assert recordarray.fieldindex("0") == 0
assert recordarray.fieldindex("two") == 1
assert recordarray.fieldindex("1") == 1
assert recordarray.fieldindex("2") == 2
assert recordarray.haskey("wonky")
assert recordarray.haskey("one")
assert recordarray.haskey("0")
assert recordarray.haskey("two")
assert recordarray.haskey("1")
assert recordarray.haskey("2")
assert recordarray.keys() == ["one", "two", "2", "wonky"]
assert [ak.to_list(x) for x in recordarray.fields()] == [
[1, 2, 3, 4, 5],
[[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],
[1, 2, 3, 4, 5],
]
pairs = recordarray.fielditems()
assert pairs[0][0] == "one"
assert pairs[1][0] == "two"
assert pairs[2][0] == "2"
assert pairs[3][0] == "wonky"
assert ak.to_list(pairs[0][1]) == [1, 2, 3, 4, 5]
assert ak.to_list(pairs[1][1]) == [
[1.1, 2.2, 3.3],
[],
[4.4, 5.5],
[6.6],
[7.7, 8.8, 9.9],
]
assert ak.to_list(
pairs[2][1]) == [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]
assert ak.to_list(pairs[3][1]) == [1, 2, 3, 4, 5]
assert (
ak.to_json(recordarray.astuple) ==
'[{"0":1,"1":[1.1,2.2,3.3],"2":1.1,"3":1},{"0":2,"1":[],"2":2.2,"3":2},{"0":3,"1":[4.4,5.5],"2":3.3,"3":3},{"0":4,"1":[6.6],"2":4.4,"3":4},{"0":5,"1":[7.7,8.8,9.9],"2":5.5,"3":5}]'
)
def test_fromiter():
builder = ak.layout.ArrayBuilder()
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 ak.to_list(builder.snapshot()) == [
0,
1,
2,
[],
[1.1],
[1.1, 2.2],
[1.1, 2.2, 3.3],
]
assert ak.to_list(
ak.from_iter([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 ak.to_list(
ak.from_iter([
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 ak.to_list(
ak.from_json(
'[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 (ak.to_json(
ak.from_json(
'[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_BitMaskedArray():
content = ak.layout.NumpyArray(np.arange(13))
mask = ak.layout.IndexU8(np.array([58, 59], dtype=np.uint8))
array = ak.layout.BitMaskedArray(mask,
content,
valid_when=False,
length=13,
lsb_order=False)
assert np.asarray(array.bytemask()).tolist() == [
0,
0,
1,
1,
1,
0,
1,
0,
0,
0,
1,
1,
1,
]
assert np.asarray(array.toByteMaskedArray().mask).tolist() == [
0,
0,
1,
1,
1,
0,
1,
0,
0,
0,
1,
1,
1,
]
assert np.asarray(array.toIndexedOptionArray64().index).tolist() == [
0,
1,
-1,
-1,
-1,
5,
-1,
7,
8,
9,
-1,
-1,
-1,
]
assert ak.to_list(array) == [
0,
1,
None,
None,
None,
5,
None,
7,
8,
9,
None,
None,
None,
]
assert ak.to_json(
array) == "[0,1,null,null,null,5,null,7,8,9,null,null,null]"
assert ak.to_list(array[1:-1]) == [
1,
None,
None,
None,
5,
None,
7,
8,
9,
None,
None,
]
assert ak.to_list(array[8:]) == [8, 9, None, None, None]
array = ak.layout.BitMaskedArray(mask,
content,
valid_when=False,
length=13,
lsb_order=True)
assert np.asarray(array.bytemask()).tolist() == [
0,
1,
0,
1,
1,
1,
0,
0,
1,
1,
0,
1,
1,
]
assert np.asarray(array.toByteMaskedArray().mask).tolist() == [
0,
1,
0,
1,
1,
1,
0,
0,
1,
1,
0,
1,
1,
]
assert np.asarray(array.toIndexedOptionArray64().index).tolist() == [
0,
-1,
2,
-1,
-1,
-1,
6,
7,
-1,
-1,
10,
-1,
-1,
]
assert ak.to_list(array) == [
0,
None,
2,
None,
None,
None,
6,
7,
None,
None,
10,
None,
None,
]
assert ak.to_json(
array) == "[0,null,2,null,null,null,6,7,null,null,10,null,null]"
assert ak.to_list(array[1:-1]) == [
None,
2,
None,
None,
None,
6,
7,
None,
None,
10,
None,
]
assert ak.to_list(array[8:]) == [None, None, 10, None, None]
