def test_unknown():
a = ak.from_json("[[], [], []]", highlevel=False)
assert ak.to_list(a) == [[], [], []]
assert str(ak.type(a)) == "var * unknown"
assert ak.type(a) == ak.types.ListType(ak.types.UnknownType())
assert not ak.type(a) == ak.types.PrimitiveType("float64")
a = ak.from_json("[[], [[], []], [[], [], []]]", highlevel=False)
assert ak.to_list(a) == [[], [[], []], [[], [], []]]
assert str(ak.type(a)) == "var * var * unknown"
assert ak.type(a) == ak.types.ListType(
ak.types.ListType(ak.types.UnknownType()))
a = ak.layout.ArrayBuilder()
a.beginlist()
a.endlist()
a.beginlist()
a.endlist()
a.beginlist()
a.endlist()
assert ak.to_list(a) == [[], [], []]
assert str(ak.type(a)) == "var * unknown"
assert ak.type(a) == ak.types.ListType(ak.types.UnknownType())
assert not ak.type(a) == ak.types.PrimitiveType("float64")
a = a.snapshot()
assert ak.to_list(a) == [[], [], []]
assert str(ak.type(a)) == "var * unknown"
assert ak.type(a) == ak.types.ListType(ak.types.UnknownType())
assert not ak.type(a) == ak.types.PrimitiveType("float64")
def test_getitem():
a = ak.from_json("[]")
a = ak.from_json("[[], [[], []], [[], [], []]]")
assert ak.to_list(a[2]) == [[], [], []]
assert ak.to_list(a[2, 1]) == []
with pytest.raises(ValueError) as excinfo:
a[2, 1, 0]
assert " attempting to get 0, index out of range" in str(excinfo.value)
assert ak.to_list(a[2, 1][()]) == []
with pytest.raises(ValueError) as excinfo:
a[2, 1][0]
assert " attempting to get 0, index out of range" in str(excinfo.value)
assert ak.to_list(a[2, 1][100:200]) == []
assert ak.to_list(a[2, 1, 100:200]) == []
assert ak.to_list(a[2, 1][np.array([], dtype=int)]) == []
assert ak.to_list(a[2, 1, np.array([], dtype=int)]) == []
with pytest.raises(ValueError) as excinfo:
a[2, 1, np.array([0], dtype=int)]
assert " attempting to get 0, index out of range" in str(excinfo.value)
with pytest.raises(ValueError) as excinfo:
a[2, 1][100:200, 0]
assert ", too many dimensions in slice" in str(excinfo.value)
with pytest.raises(ValueError) as excinfo:
a[2, 1][100:200, 200:300]
assert ", too many dimensions in slice" in str(excinfo.value)
with pytest.raises(ValueError) as excinfo:
a[2, 1][100:200, np.array([], dtype=int)]
assert ", too many dimensions in slice" in str(excinfo.value)
assert ak.to_list(a[1:, 1:]) == [[[]], [[], []]]
with pytest.raises(ValueError) as excinfo:
a[1:, 1:, 0]
assert " attempting to get 0, index out of range" in str(excinfo.value)
def test_blanc_lines():
str = """{"one": 1, "two": 2.2}
{"one": 10, "two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{"one": 1, "two": 2.2}, {"one": 10, "two": 22.0}]
str = """{"one": 1, "two": 2.2}
{"one": 10, "two": 22}
"""
array = ak.from_json(str)
assert ak.to_list(array) == [{"one": 1, "two": 2.2}, {"one": 10, "two": 22.0}]
str = """ 1
2
3 """
array = ak.from_json(str)
assert ak.to_list(array) == [1, 2, 3]
str = """
1
2
3
"""
array = ak.from_json(str)
assert ak.to_list(array) == [1, 2, 3]
def test():
url = "https://raw.githubusercontent.com/Chicago/osd-bike-routes/5f556dc/data/Bikeroutes.geojson"
try:
bikeroutes_json = urllib.request.urlopen(url).read()
except urllib.error.URLError:
pytest.skip(msg="couldn't download sample dataset")
# This shouldn't fail (see #1084)
ak.from_json(bikeroutes_json)
def test_fromfile(tmp_path):
with open(os.path.join(str(tmp_path), "tmp1.json"), "w") as f:
f.write("[[1.1, 2.2, 3], [], [4, 5.5]]")
a = ak.from_json(os.path.join(str(tmp_path), "tmp1.json"))
assert ak.to_list(a) == [[1.1, 2.2, 3.0], [], [4.0, 5.5]]
with pytest.raises(ValueError):
ak.from_json("nonexistent.json")
with open(os.path.join(str(tmp_path), "tmp2.json"), "w") as f:
f.write("[[1.1, 2.2, 3], []], [4, 5.5]]")
with pytest.raises(ValueError):
ak.from_json(os.path.join(str(tmp_path), "tmp2.json"))
def test_empty_array_slice():
# inspired by PR021::test_getitem
a = ak.from_json("[[], [[], []], [[], [], []]]")
assert ak.to_list(a[2, 1, np.array([], dtype=int)]) == []
assert ak.to_list(a[2,
np.array([1], dtype=int),
np.array([], dtype=int)]) == []
# inspired by PR015::test_deep_numpy
content = ak.layout.NumpyArray(
np.array([[0.0, 1.1], [2.2, 3.3], [4.4, 5.5], [6.6, 7.7], [8.8, 9.9]]))
listarray = ak.layout.ListArray64(
ak.layout.Index64(np.array([0, 3, 3])),
ak.layout.Index64(np.array([3, 3, 5])),
content,
)
assert ak.to_list(listarray[[2, 0, 0, -1], [1, -1, 0, 0],
[0, 1, 0, 1]]) == [
8.8,
5.5,
0.0,
7.7,
]
assert ak.to_list(listarray[2, 1, np.array([], dtype=int)]) == []
assert ak.to_list(listarray[2, 1, []]) == []
assert ak.to_list(listarray[2, [1], []]) == []
assert ak.to_list(listarray[2, [], []]) == []
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_fromiter_fromjson():
assert ak.to_list(ak.from_iter(["one", "two",
"three"])) == ["one", "two", "three"]
assert ak.to_list(
ak.from_iter([["one", "two", "three"], [],
["four", "five"]])) == [["one", "two", "three"], [],
["four", "five"]]
assert ak.to_list(ak.from_json('["one", "two", "three"]')) == [
"one",
"two",
"three",
]
assert ak.to_list(
ak.from_json('[["one", "two", "three"], [], ["four", "five"]]')) == [[
"one", "two", "three"
], [], ["four", "five"]]
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 test_jpivarski():
assert ak.from_json('{"x": 1, "y": [1, 2, 3]}').tolist() == {
"x": 1,
"y": [1, 2, 3]
}
assert ak.from_json(
'{"x": 1, "y": [1, 2, 3]} {"x": 2, "y": []}').tolist() == [
{
"x": 1,
"y": [1, 2, 3]
},
{
"x": 2,
"y": []
},
]
assert ak.from_json('{"x": 1, "y": [1, 2, 3]} 123').tolist() == [
{
"x": 1,
"y": [1, 2, 3]
},
123,
]
assert ak.from_json(
'{"x": 1, "y": [1, 2, 3]} [1, 2, 3, 4, 5]').tolist() == [
{
"x": 1,
"y": [1, 2, 3]
},
[1, 2, 3, 4, 5],
]
assert ak.from_json("123") == 123
assert ak.from_json("123 456").tolist() == [123, 456]
assert ak.from_json('123 {"x": 1, "y": [1, 2, 3]}').tolist() == [
123,
{
"x": 1,
"y": [1, 2, 3]
},
]
assert ak.from_json("null") is None
assert ak.from_json("null 123").tolist() == [None, 123]
assert ak.from_json("123 null").tolist() == [123, None]
def test_fromstring():
# read 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]},
]
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_from_json():
array = ak.from_json('[{"r": 1.1, "i": 1.0}, {"r": 2.2, "i": 2.0}]')
assert array.tolist() == [
{
"r": 1.1,
"i": 1.0
},
{
"r": 2.2,
"i": 2.0
},
]
array = ak.from_json('[{"r": 1.1, "i": 1.0}, {"r": 2.2, "i": 2.0}]',
complex_record_fields=("r", "i"))
assert array.tolist() == [(1.1 + 1j), (2.2 + 2j)]
# Somewhere in from_json, a handler that turns integer record fields into
# parts of a complex number is missing.
array = ak.from_json('[{"r": 1, "i": 1}, {"r": 2, "i": 2}]',
complex_record_fields=("r", "i"))
assert array.tolist() == [(1 + 1j), (2 + 2j)]
# This should fail with some message like "complex number fields must be numbers,"
# not "called 'end_record' without 'begin_record' at the same level before it."
with pytest.raises(ValueError) as err:
array = ak.from_json(
'[{"r": [], "i": 1}, {"r": [1, 2], "i": 2}]',
complex_record_fields=("r", "i"),
)
assert array["r"].type == array["i"].type
assert "Complex number fields must be numbers" in str(err)
# These shouldn't be recognized as complex number records because they have
# only one of the two fields.
assert ak.from_json('[{"r": 1}, {"r": 2}]',
complex_record_fields=("r", "i")).tolist() == [{
"r": 1
}, {
"r": 2
}]
assert ak.from_json('[{"i": 1}, {"i": 2}]',
complex_record_fields=("r", "i")).tolist() == [{
"i": 1
}, {
"i": 2
}]
assert ak.from_json('[{"r": 1.1}, {"r": 2.2}]',
complex_record_fields=("r", "i")).tolist() == [{
"r": 1.1
}, {
"r": 2.2
}]
assert ak.from_json('[{"i": 1.1}, {"i": 2.2}]',
complex_record_fields=("r", "i")).tolist() == [{
"i": 1.1
}, {
"i": 2.2
}]
# In this one, the extra field should simply be ignored. A record with *at least*
# the two specified fields should be recognized as a complex number, so that
# the protocol can include a type marker, as some protocols do.
array = ak.from_json(
'[{"r": 1.1, "i": 1.0, "another": []}, {"r": 2.2, "i": 2.0, "another": [1, 2, 3]}]',
complex_record_fields=("r", "i"),
)
assert array.tolist() == [(1.1 + 1j), (2.2 + 2j)]
def test_lazy_arrayset():
array = ak.from_json(
"""
[
{
"listcollection": [
{"item1": 1, "item2": 2},
{"item1": 2, "item2": 4},
{"item1": 3, "item2": 6}
],
"collection": {"item1": 3, "item2": 4},
"singleton": 5,
"listsingleton": [1, 2, 3],
"unioncollection": {"item1": 3},
"masked": null
},
{
"listcollection": [
{"item1": 1, "item2": 2},
{"item1": 2, "item2": 4},
{"item1": 3, "item2": 6}
],
"collection": {"item1": 3, "item2": 4},
"singleton": 5,
"listsingleton": [1, 2, 3],
"unioncollection": [{"item1": 2}],
"masked": 4
},
{
"listcollection": [
{"item1": 1, "item2": 2},
{"item1": 2, "item2": 4},
{"item1": 3, "item2": 6}
],
"collection": {"item1": 3, "item2": 4},
"singleton": 5,
"listsingleton": [1, 2, 3],
"unioncollection": {"item1": 4},
"masked": 4
}
]"""
)
canary = Canary()
prefix = "kitty"
form, container, npart = ak.to_arrayset(array, container=canary, prefix=prefix)
assert not any(op[0] == "get" for op in canary.ops)
canary.ops = []
cache = {}
out = ak.from_arrayset(
form,
container,
lazy=True,
lazy_cache=cache,
lazy_lengths=3,
prefix=prefix,
lazy_cache_key="hello",
)
assert len(canary.ops) == 0
assert len(cache) == 0
assert len(out) == 3
assert len(canary.ops) == 0
assert len(cache) == 0
assert ak.to_list(ak.num(out.listcollection)) == [3, 3, 3]
assert set(canary.ops) == {("get", "kitty-node1-offsets")}
assert set(cache) == {"hello", "hello-kitty-node1-virtual"}
canary.ops = []
cache.clear()
assert ak.to_list(out.unioncollection) == [
{"item1": 3},
[{"item1": 2}],
{"item1": 4},
]
assert set(canary.ops) == {
("get", "kitty-node11-tags"),
("get", "kitty-node11-index"),
("get", "kitty-node14-offsets"),
("get", "kitty-node13"),
("get", "kitty-node16"),
}
assert set(cache) == {
"hello",
"hello-kitty-node11-virtual",
"hello-kitty-node13-virtual",
"hello-kitty-node16-virtual",
}
canary.ops = []
cache.clear()
assert ak.to_list(out.masked) == [None, 4, 4]
assert set(canary.ops) == {("get", "kitty-node17-index"), ("get", "kitty-node18")}
assert set(cache) == {"hello", "hello-kitty-node17-virtual"}
canary.ops = []
cache.clear()
def test_unfinished_fragment_exception():
# read unfinished json fragments
strs0 = """{"one": 1, "two": 2.2,"""
with pytest.raises(ValueError):
ak.from_json(strs0)
strs1 = """{"one": 1,
"two": 2.2,"""
with pytest.raises(ValueError):
ak.from_json(strs1)
strs2 = """{"one": 1,
"two": 2.2,
"""
with pytest.raises(ValueError):
ak.from_json(strs2)
strs3 = """{"one": 1, "two": 2.2, "three": "THREE"}
{"one": 10, "two": 22,"""
with pytest.raises(ValueError):
ak.from_json(strs3)
strs4 = """{"one": 1, "two": 2.2, "three": "THREE"}
{"one": 10, "two": 22,
"""
with pytest.raises(ValueError):
ak.from_json(strs4)
strs5 = """["one", "two","""
with pytest.raises(ValueError):
ak.from_json(strs5)
strs6 = """["one",
"two","""
with pytest.raises(ValueError):
ak.from_json(strs6)
strs7 = """["one",
"two",
"""
with pytest.raises(ValueError):
ak.from_json(strs7)
def test_fromstring():
a = ak.from_json("[[1.1, 2.2, 3], [], [4, 5.5]]")
assert ak.to_list(a) == [[1.1, 2.2, 3.0], [], [4.0, 5.5]]
with pytest.raises(ValueError):
ak.from_json("[[1.1, 2.2, 3], [blah], [4, 5.5]]")
def test_lazy_buffers():
array = ak.from_json("""
[
{
"listcollection": [
{"item1": 1, "item2": 2},
{"item1": 2, "item2": 4},
{"item1": 3, "item2": 6}
],
"collection": {"item1": 3, "item2": 4},
"singleton": 5,
"listsingleton": [1, 2, 3],
"unioncollection": {"item1": 3},
"masked": null
},
{
"listcollection": [
{"item1": 1, "item2": 2},
{"item1": 2, "item2": 4},
{"item1": 3, "item2": 6}
],
"collection": {"item1": 3, "item2": 4},
"singleton": 5,
"listsingleton": [1, 2, 3],
"unioncollection": [{"item1": 2}],
"masked": 4
},
{
"listcollection": [
{"item1": 1, "item2": 2},
{"item1": 2, "item2": 4},
{"item1": 3, "item2": 6}
],
"collection": {"item1": 3, "item2": 4},
"singleton": 5,
"listsingleton": [1, 2, 3],
"unioncollection": {"item1": 4},
"masked": 4
}
]""")
canary = Canary()
key_format = "kitty-{form_key}-{attribute}"
form, length, container = ak.to_buffers(array,
container=canary,
key_format=key_format)
assert not any(op[0] == "get" for op in canary.ops)
canary.ops = []
cache = {}
out = ak.from_buffers(
form,
length,
container,
key_format=key_format,
lazy=True,
lazy_cache=cache,
lazy_cache_key="hello",
)
assert len(canary.ops) == 0
assert len(cache) == 0
assert len(out) == 3
assert len(canary.ops) == 0
assert len(cache) == 0
assert ak.to_list(ak.num(out.listcollection)) == [3, 3, 3]
assert set(canary.ops) == {("get", "kitty-node1-offsets")}
assert "hello" in cache
assert "hello(kitty-node1-virtual)" in cache
canary.ops = []
cache.clear()
assert ak.to_list(out.unioncollection) == [
{
"item1": 3
},
[{
"item1": 2
}],
{
"item1": 4
},
]
assert set(canary.ops) == {
("get", "kitty-node11-tags"),
("get", "kitty-node11-index"),
("get", "kitty-node14-offsets"),
("get", "kitty-node13-data"),
("get", "kitty-node16-data"),
}
assert "hello" in cache
assert "hello(kitty-node11-virtual)" in cache
assert "hello(kitty-node13-virtual)" in cache
assert "hello(kitty-node16-virtual)" in cache
canary.ops = []
cache.clear()
assert ak.to_list(out.masked) == [None, 4, 4]
assert set(canary.ops) == {
("get", "kitty-node17-index"),
("get", "kitty-node18-data"),
}
assert "hello" in cache
assert "hello(kitty-node17-virtual)" in cache
canary.ops = []
cache.clear()
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_two_arrays():
str = """{"one": 1, "two": 2.2}{"one": 10, "two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, "two": 2.2} {"one": 10, "two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, \t "two": 2.2}{"one": 10, "two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, "two": 2.2} \t {"one": 10, "two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, "two": 2.2}\n{"one": 10, "two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, "two": 2.2}\n\r{"one": 10, "two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, "two": 2.2} \n {"one": 10, "two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, "two": 2.2} \n\r {"one": 10, "two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, "two": 2.2}{"one": 10, "two": 22}\n"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, "two": 2.2}{"one": 10, "two": 22}\n\r"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, "two": 2.2}\n{"one": 10, "two": 22}\n"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, "two": 2.2}\n\r{"one": 10, "two": 22}\n\r"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, \n"two": 2.2}{"one": 10, "two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, \n\r"two": 2.2}{"one": 10, "two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, \n"two": 2.2}\n{"one": 10, "two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, \n\r"two": 2.2}\n\r{"one": 10, "two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, \n"two": 2.2}\n{"one": 10, "two": 22}\n"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, \n\r"two": 2.2}\n\r{"one": 10, "two": 22}\n\r"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, "two": 2.2}{"one": 10, \n"two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, "two": 2.2}{"one": 10, \n\r"two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, "two": 2.2}\n{"one": 10, \n"two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """{"one": 1, "two": 2.2}\n\r{"one": 10, \n\r"two": 22}"""
array = ak.from_json(str)
assert ak.to_list(array) == [{
"one": 1,
"two": 2.2
}, {
"one": 10,
"two": 22.0
}]
str = """["one", "two"]["uno", "dos"]"""
array = ak.from_json(str)
assert ak.to_list(array) == [["one", "two"], ["uno", "dos"]]
str = """["one", "two"]\n["uno", "dos"]"""
array = ak.from_json(str)
assert ak.to_list(array) == [["one", "two"], ["uno", "dos"]]
str = """["one", "two"]\n\r["uno", "dos"]"""
array = ak.from_json(str)
assert ak.to_list(array) == [["one", "two"], ["uno", "dos"]]
str = """["one", "two"] ["uno", "dos"]"""
array = ak.from_json(str)
assert ak.to_list(array) == [["one", "two"], ["uno", "dos"]]
str = """["one", "two"] \n ["uno", "dos"]"""
array = ak.from_json(str)
assert ak.to_list(array) == [["one", "two"], ["uno", "dos"]]
str = """["one", "two"] \n\r ["uno", "dos"]"""
array = ak.from_json(str)
assert ak.to_list(array) == [["one", "two"], ["uno", "dos"]]
str = """["one", \n "two"]["uno", "dos"]"""
array = ak.from_json(str)
assert ak.to_list(array) == [["one", "two"], ["uno", "dos"]]
str = """["one", \n "two"]\n["uno", "dos"]"""
array = ak.from_json(str)
assert ak.to_list(array) == [["one", "two"], ["uno", "dos"]]
str = """["one", \n\r "two"]["uno", "dos"]"""
array = ak.from_json(str)
assert ak.to_list(array) == [["one", "two"], ["uno", "dos"]]
str = """["one", \n\r "two"]\n\r["uno", "dos"]"""
array = ak.from_json(str)
assert ak.to_list(array) == [["one", "two"], ["uno", "dos"]]
str = '"one""two"'
array = ak.from_json(str)
assert ak.to_list(array) == ["one", "two"]
str = '"one"\n"two"'
array = ak.from_json(str)
assert ak.to_list(array) == ["one", "two"]
str = '"one"\n\r"two"'
array = ak.from_json(str)
assert ak.to_list(array) == ["one", "two"]
str = '"one" "two"'
array = ak.from_json(str)
assert ak.to_list(array) == ["one", "two"]
str = '"one" \n "two"'
array = ak.from_json(str)
assert ak.to_list(array) == ["one", "two"]
str = '"one" \n\r "two"'
array = ak.from_json(str)
assert ak.to_list(array) == ["one", "two"]
array = ak.from_json(os.path.join(DIR, "samples/test-two-arrays.json"))
assert ak.to_list(array) == [
{
"one": 1,
"two": 2.2
},
{
"one": 10,
"two": 22.0
},
{
"one": 1,
"two": 2.2
},
{
"one": 10,
"two": 22.0
},
{
"one": 1,
"two": 2.2
},
{
"one": 10,
"two": 22.0
},
{
"one": 1,
"two": 2.2
},
{
"one": 10,
"two": 22.0
},
{
"one": 1,
"two": 2.2
},
{
"one": 10,
"two": 22.0
},
{
"one": 1,
"two": 2.2
},
{
"one": 10,
"two": 22.0
},
{
"one": 1,
"two": 2.2
},
{
"one": 10,
"two": 22.0
},
{
"one": 1,
"two": 2.2
},
{
"one": 10,
"two": 22.0
},
{
"one": 1,
"two": 2.2
},
{
"one": 10,
"two": 22.0
},
{
"one": 1,
"two": 2.2
},
{
"one": 10,
"two": 22.0
},
{
"one": 1,
"two": 2.2
},
{
"one": 10,
"two": 22.0
},
["one", "two"],
["uno", "dos"],
["one", "two"],
["uno", "dos"],
["one", "two"],
["uno", "dos"],
["one", "two"],
["uno", "dos"],
["one", "two"],
["uno", "dos"],
["one", "two"],
["uno", "dos"],
"one",
"two",
"one",
"two",
"one",
"two",
"one",
"two",
"one",
"two",
"one",
"two",
]
def test_three():
array = ak.from_json('["one", \n"two"] \n ["three"]')
assert ak.to_list(array) == [["one", "two"], ["three"]]
def test_fromfile():
# read multiple json fragments from a json file
array = ak.from_json(os.path.join(DIR, "samples/test-record-array.json"))
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]
},
]
# read json file containg 'nan' and 'inf' user-defined strings
# and replace 'nan' and 'inf' strings with floats
array = ak.from_json(
os.path.join(DIR, "samples/test.json"),
infinity_string="inf",
minus_infinity_string="-inf",
)
assert ak.to_list(array) == [
1.1,
2.2,
3.3,
float("inf"),
float("-inf"),
[4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.1, 11.11],
[12.12, 13.13, 14.14, 15.15, 16.16, 17.17],
[
[
[18.18, 19.19, 20.2, 21.21, 22.22],
[
23.23,
24.24,
25.25,
26.26,
27.27,
28.28,
29.29,
30.3,
31.31,
32.32,
33.33,
34.34,
35.35,
36.36,
37.37,
],
[38.38],
[39.39, 40.4, "NaN", "NaN", 41.41, 42.42, 43.43],
],
[
[44.44, 45.45, 46.46, 47.47, 48.48],
[
49.49,
50.5,
51.51,
52.52,
53.53,
54.54,
55.55,
56.56,
57.57,
58.58,
59.59,
60.6,
61.61,
62.62,
63.63,
],
[64.64],
[65.65, 66.66, "NaN", "NaN", 67.67, 68.68, 69.69],
],
],
]
# read json file containg 'nan' and 'inf' user-defined strings
array = ak.from_json(os.path.join(DIR, "samples/test.json"))
assert ak.to_list(array) == [
1.1,
2.2,
3.3,
"inf",
"-inf",
[4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.1, 11.11],
[12.12, 13.13, 14.14, 15.15, 16.16, 17.17],
[
[
[18.18, 19.19, 20.2, 21.21, 22.22],
[
23.23,
24.24,
25.25,
26.26,
27.27,
28.28,
29.29,
30.3,
31.31,
32.32,
33.33,
34.34,
35.35,
36.36,
37.37,
],
[38.38],
[39.39, 40.4, "NaN", "NaN", 41.41, 42.42, 43.43],
],
[
[44.44, 45.45, 46.46, 47.47, 48.48],
[
49.49,
50.5,
51.51,
52.52,
53.53,
54.54,
55.55,
56.56,
57.57,
58.58,
59.59,
60.6,
61.61,
62.62,
63.63,
],
[64.64],
[65.65, 66.66, "NaN", "NaN", 67.67, 68.68, 69.69],
],
],
]
# read json file containg 'nan' and 'inf' user-defined strings
# and replace 'nan' and 'inf' strings with a predefined 'None' string
array = ak.from_json(
os.path.join(DIR, "samples/test.json"),
infinity_string="inf",
minus_infinity_string="-inf",
nan_string="NaN",
)
def fix(obj):
if isinstance(obj, list):
return [fix(x) for x in obj]
elif np.isnan(obj):
return "COMPARE-NAN"
else:
return obj
assert fix(ak.to_list(array)) == fix([
1.1,
2.2,
3.3,
float("inf"),
float("-inf"),
[4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.1, 11.11],
[12.12, 13.13, 14.14, 15.15, 16.16, 17.17],
[
[
[18.18, 19.19, 20.2, 21.21, 22.22],
[
23.23,
24.24,
25.25,
26.26,
27.27,
28.28,
29.29,
30.3,
31.31,
32.32,
33.33,
34.34,
35.35,
36.36,
37.37,
],
[38.38],
[39.39, 40.4,
float("nan"),
float("nan"), 41.41, 42.42, 43.43],
],
[
[44.44, 45.45, 46.46, 47.47, 48.48],
[
49.49,
50.5,
51.51,
52.52,
53.53,
54.54,
55.55,
56.56,
57.57,
58.58,
59.59,
60.6,
61.61,
62.62,
63.63,
],
[64.64],
[
65.65, 66.66,
float("nan"),
float("nan"), 67.67, 68.68, 69.69
],
],
],
])
# read json file containing multiple definitions of 'nan' and 'inf'
# user-defined strings
# replace can only work for one string definition
array = ak.from_json(
os.path.join(DIR, "samples/test-nan-inf.json"),
infinity_string="Infinity",
nan_string="None",
)
assert ak.to_list(array) == [
1.1,
2.2,
3.3,
"inf",
"-inf",
[4.4, float("inf"), 6.6, 7.7, 8.8, "NaN", 10.1, 11.11],
[12.12, 13.13, 14.14, 15.15, 16.16, 17.17],
[
[
[18.18, 19.19, 20.2, 21.21, 22.22],
[
23.23,
24.24,
25.25,
26.26,
27.27,
28.28,
29.29,
30.3,
31.31,
32.32,
33.33,
34.34,
35.35,
36.36,
37.37,
],
[38.38],
[39.39, 40.4, "NaN", "NaN", 41.41, 42.42, 43.43],
],
[
[44.44, 45.45, 46.46, 47.47, 48.48],
[
49.49,
50.5,
51.51,
52.52,
53.53,
54.54,
55.55,
56.56,
57.57,
58.58,
59.59,
60.6,
61.61,
62.62,
63.63,
],
[64.64],
[65.65, 66.66, "NaN", "NaN", 67.67, 68.68, 69.69],
],
],
]
