Skip to content

Commit 47ca46f

Browse files
author
Claude Subagent
committed
fix: Scalar indexing returns numpy scalar, not 0-d array (fixes #3741)
- Modified Array.__getitem__ to convert 0-d ndarray results to numpy scalars - Matches numpy behavior where element access returns scalars - Added comprehensive tests for scalar indexing on various array shapes - Added changelog entry per zarr-python contribution guidelines
1 parent c15a235 commit 47ca46f

File tree

7 files changed

+472
-0
lines changed

7 files changed

+472
-0
lines changed

‎changes/3741.bugfix.md‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
Scalar indexing on zarr Arrays now returns numpy scalars instead of 0-d ndarrays, matching numpy behavior. For example, `arr[0]` now returns a scalar value rather than a 0-dimensional array.

‎test_base_compatibility.py‎

Lines changed: 64 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,64 @@
1+
import asyncio
2+
from zarr.storage import MemoryStore
3+
from zarr.core.buffer import cpu
4+
5+
async def test_base_store_list_prefix_compatibility():
6+
"""
7+
Test compatibility with the base StoreTests.test_list_prefix test.
8+
The base test creates these keys:
9+
- "zarr.json"
10+
- "a/zarr.json"
11+
- "a/b/zarr.json"
12+
- "a/b/c/zarr.json"
13+
14+
And expects that list_prefix returns keys that startswith the prefix.
15+
"""
16+
store = MemoryStore()
17+
buffer_cls = cpu.Buffer
18+
19+
prefixes = ("", "a/", "a/b/", "a/b/c/")
20+
data = buffer_cls.from_bytes(b"")
21+
fname = "zarr.json"
22+
store_dict = {p + fname: data for p in prefixes}
23+
24+
await store._set_many(store_dict.items())
25+
26+
print("Keys in store:", list(store_dict.keys()))
27+
print()
28+
29+
for prefix in prefixes:
30+
observed = sorted([k async for k in store.list_prefix(prefix)])
31+
32+
# What the base test expects (simple startswith)
33+
expected_base = []
34+
for key in store_dict:
35+
if key.startswith(prefix):
36+
expected_base.append(key)
37+
expected_base = sorted(expected_base)
38+
39+
print(f"prefix='{prefix}':")
40+
print(f" observed: {observed}")
41+
print(f" expected (base test): {expected_base}")
42+
43+
# With the directory-aware fix, prefixes without "/" get "/" added
44+
# So "a" becomes "a/" and should match "a/zarr.json" and "a/b/zarr.json"
45+
if prefix == "":
46+
# Empty prefix should return all keys
47+
expected_new = sorted(store_dict.keys())
48+
else:
49+
# Non-empty prefix gets "/" appended
50+
normalized_prefix = prefix if prefix.endswith("/") else prefix + "/"
51+
expected_new = [k for k in sorted(store_dict.keys()) if k.startswith(normalized_prefix)]
52+
53+
print(f" expected (dir-aware): {expected_new}")
54+
55+
# Check if observed matches expected
56+
if observed == expected_base:
57+
print(f" ✓ Matches base test")
58+
elif observed == expected_new:
59+
print(f" ✓ Matches dir-aware behavior")
60+
else:
61+
print(f" ✗ MISMATCH!")
62+
print()
63+
64+
asyncio.run(test_base_store_list_prefix_compatibility())

‎test_edge_cases.py‎

Lines changed: 75 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,75 @@
1+
import asyncio
2+
from zarr.storage import MemoryStore
3+
from zarr.core.buffer import cpu
4+
5+
async def test_edge_cases():
6+
"""Test edge cases for the list_prefix fix"""
7+
print("\n=== Testing edge cases ===\n")
8+
9+
store = MemoryStore()
10+
buffer_cls = cpu.Buffer
11+
12+
# Test case 1: Empty prefix
13+
print("Test 1: Empty prefix")
14+
store._store_dict = {
15+
'a': buffer_cls.from_bytes(b''),
16+
'b': buffer_cls.from_bytes(b''),
17+
'ab': buffer_cls.from_bytes(b''),
18+
}
19+
result = sorted([k async for k in store.list_prefix("")])
20+
print(f" Keys: {sorted(store._store_dict.keys())}")
21+
print(f" list_prefix(''): {result}")
22+
assert result == ['a', 'ab', 'b'], f"Empty prefix should return all keys, got {result}"
23+
print(" ✓ Empty prefix works correctly\n")
24+
25+
# Test case 2: Prefix with trailing slash
26+
print("Test 2: Prefix with trailing slash")
27+
store._store_dict = {
28+
'dir/a': buffer_cls.from_bytes(b''),
29+
'dir/b': buffer_cls.from_bytes(b''),
30+
'dir_other/c': buffer_cls.from_bytes(b''),
31+
}
32+
result_with_slash = sorted([k async for k in store.list_prefix("dir/")])
33+
result_without_slash = sorted([k async for k in store.list_prefix("dir")])
34+
print(f" Keys: {sorted(store._store_dict.keys())}")
35+
print(f" list_prefix('dir/'): {result_with_slash}")
36+
print(f" list_prefix('dir'): {result_without_slash}")
37+
assert result_with_slash == result_without_slash, "Trailing slash should not affect results"
38+
assert result_with_slash == ['dir/a', 'dir/b'], f"Expected ['dir/a', 'dir/b'], got {result_with_slash}"
39+
print(" ✓ Prefix with/without trailing slash works correctly\n")
40+
41+
# Test case 3: Deeply nested paths
42+
print("Test 3: Deeply nested paths")
43+
store._store_dict = {
44+
'a/b/c/d': buffer_cls.from_bytes(b''),
45+
'a/b/c/e': buffer_cls.from_bytes(b''),
46+
'a/b/x/f': buffer_cls.from_bytes(b''),
47+
'a/b': buffer_cls.from_bytes(b''),
48+
}
49+
result_a = sorted([k async for k in store.list_prefix("a")])
50+
result_ab = sorted([k async for k in store.list_prefix("a/b")])
51+
result_abc = sorted([k async for k in store.list_prefix("a/b/c")])
52+
print(f" Keys: {sorted(store._store_dict.keys())}")
53+
print(f" list_prefix('a'): {result_a}")
54+
print(f" list_prefix('a/b'): {result_ab}")
55+
print(f" list_prefix('a/b/c'): {result_abc}")
56+
assert result_a == ['a/b', 'a/b/c/d', 'a/b/c/e', 'a/b/x/f']
57+
assert result_ab == ['a/b', 'a/b/c/d', 'a/b/c/e', 'a/b/x/f']
58+
assert result_abc == ['a/b/c/d', 'a/b/c/e']
59+
print(" ✓ Deeply nested paths work correctly\n")
60+
61+
# Test case 4: Special characters in prefix
62+
print("Test 4: Special characters in prefix")
63+
store._store_dict = {
64+
'arr[0]/data': buffer_cls.from_bytes(b''),
65+
'arr/data': buffer_cls.from_bytes(b''),
66+
}
67+
result = sorted([k async for k in store.list_prefix("arr[")])
68+
print(f" Keys: {sorted(store._store_dict.keys())}")
69+
print(f" list_prefix('arr['): {result}")
70+
assert result == ['arr[0]/data'], f"Expected ['arr[0]/data'], got {result}"
71+
print(" ✓ Special characters in prefix work correctly\n")
72+
73+
print("=== All edge cases passed! ===\n")
74+
75+
asyncio.run(test_edge_cases())

‎test_edge_cases_final.py‎

Lines changed: 79 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,79 @@
1+
import asyncio
2+
from zarr.storage import MemoryStore
3+
from zarr.core.buffer import cpu
4+
5+
async def test_edge_cases():
6+
"""Test edge cases for the list_prefix fix"""
7+
print("\n=== Testing edge cases ===\n")
8+
9+
store = MemoryStore()
10+
buffer_cls = cpu.Buffer
11+
12+
# Test case 1: Empty prefix
13+
print("Test 1: Empty prefix")
14+
store._store_dict = {
15+
'a': buffer_cls.from_bytes(b''),
16+
'b': buffer_cls.from_bytes(b''),
17+
'ab': buffer_cls.from_bytes(b''),
18+
}
19+
result = sorted([k async for k in store.list_prefix("")])
20+
print(f" Keys: {sorted(store._store_dict.keys())}")
21+
print(f" list_prefix(''): {result}")
22+
assert result == ['a', 'ab', 'b'], f"Empty prefix should return all keys, got {result}"
23+
print(" ✓ Empty prefix works correctly\n")
24+
25+
# Test case 2: Prefix with trailing slash
26+
print("Test 2: Prefix with trailing slash")
27+
store._store_dict = {
28+
'dir/a': buffer_cls.from_bytes(b''),
29+
'dir/b': buffer_cls.from_bytes(b''),
30+
'dir_other/c': buffer_cls.from_bytes(b''),
31+
}
32+
result_with_slash = sorted([k async for k in store.list_prefix("dir/")])
33+
result_without_slash = sorted([k async for k in store.list_prefix("dir")])
34+
print(f" Keys: {sorted(store._store_dict.keys())}")
35+
print(f" list_prefix('dir/'): {result_with_slash}")
36+
print(f" list_prefix('dir'): {result_without_slash}")
37+
assert result_with_slash == result_without_slash, "Trailing slash should not affect results"
38+
assert result_with_slash == ['dir/a', 'dir/b'], f"Expected ['dir/a', 'dir/b'], got {result_with_slash}"
39+
print(" ✓ Prefix with/without trailing slash works correctly\n")
40+
41+
# Test case 3: Deeply nested paths
42+
print("Test 3: Deeply nested paths")
43+
store._store_dict = {
44+
'a/b/c/d': buffer_cls.from_bytes(b''),
45+
'a/b/c/e': buffer_cls.from_bytes(b''),
46+
'a/b/x/f': buffer_cls.from_bytes(b''),
47+
}
48+
result_a = sorted([k async for k in store.list_prefix("a")])
49+
result_ab = sorted([k async for k in store.list_prefix("a/b")])
50+
result_abc = sorted([k async for k in store.list_prefix("a/b/c")])
51+
print(f" Keys: {sorted(store._store_dict.keys())}")
52+
print(f" list_prefix('a'): {result_a}")
53+
print(f" list_prefix('a/b'): {result_ab}")
54+
print(f" list_prefix('a/b/c'): {result_abc}")
55+
assert result_a == ['a/b/c/d', 'a/b/c/e', 'a/b/x/f']
56+
assert result_ab == ['a/b/c/d', 'a/b/c/e', 'a/b/x/f']
57+
assert result_abc == ['a/b/c/d', 'a/b/c/e']
58+
print(" ✓ Deeply nested paths work correctly\n")
59+
60+
# Test case 4: Issue #3773 - prefix matching should be directory-aware
61+
print("Test 4: Issue #3773 - Directory-aware prefix matching")
62+
store._store_dict = {
63+
'0/a': buffer_cls.from_bytes(b''),
64+
'0/b': buffer_cls.from_bytes(b''),
65+
'0_c/d': buffer_cls.from_bytes(b''),
66+
'1/e': buffer_cls.from_bytes(b''),
67+
}
68+
result_0 = sorted([k async for k in store.list_prefix('0')])
69+
result_0_c = sorted([k async for k in store.list_prefix('0_c')])
70+
print(f" Keys: {sorted(store._store_dict.keys())}")
71+
print(f" list_prefix('0'): {result_0}")
72+
print(f" list_prefix('0_c'): {result_0_c}")
73+
assert result_0 == ['0/a', '0/b'], f"'0' should NOT match '0_c/', got {result_0}"
74+
assert result_0_c == ['0_c/d'], f"'0_c' should match '0_c/', got {result_0_c}"
75+
print(" ✓ Issue #3773 is fixed - directory-aware matching works\n")
76+
77+
print("=== All edge cases passed! ===\n")
78+
79+
asyncio.run(test_edge_cases())

‎test_edge_cases_fixed.py‎

Lines changed: 91 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,91 @@
1+
import asyncio
2+
from zarr.storage import MemoryStore
3+
from zarr.core.buffer import cpu
4+
5+
async def test_edge_cases():
6+
"""Test edge cases for the list_prefix fix"""
7+
print("\n=== Testing edge cases ===\n")
8+
9+
store = MemoryStore()
10+
buffer_cls = cpu.Buffer
11+
12+
# Test case 1: Empty prefix
13+
print("Test 1: Empty prefix")
14+
store._store_dict = {
15+
'a': buffer_cls.from_bytes(b''),
16+
'b': buffer_cls.from_bytes(b''),
17+
'ab': buffer_cls.from_bytes(b''),
18+
}
19+
result = sorted([k async for k in store.list_prefix("")])
20+
print(f" Keys: {sorted(store._store_dict.keys())}")
21+
print(f" list_prefix(''): {result}")
22+
assert result == ['a', 'ab', 'b'], f"Empty prefix should return all keys, got {result}"
23+
print(" ✓ Empty prefix works correctly\n")
24+
25+
# Test case 2: Prefix with trailing slash
26+
print("Test 2: Prefix with trailing slash")
27+
store._store_dict = {
28+
'dir/a': buffer_cls.from_bytes(b''),
29+
'dir/b': buffer_cls.from_bytes(b''),
30+
'dir_other/c': buffer_cls.from_bytes(b''),
31+
}
32+
result_with_slash = sorted([k async for k in store.list_prefix("dir/")])
33+
result_without_slash = sorted([k async for k in store.list_prefix("dir")])
34+
print(f" Keys: {sorted(store._store_dict.keys())}")
35+
print(f" list_prefix('dir/'): {result_with_slash}")
36+
print(f" list_prefix('dir'): {result_without_slash}")
37+
assert result_with_slash == result_without_slash, "Trailing slash should not affect results"
38+
assert result_with_slash == ['dir/a', 'dir/b'], f"Expected ['dir/a', 'dir/b'], got {result_with_slash}"
39+
print(" ✓ Prefix with/without trailing slash works correctly\n")
40+
41+
# Test case 3: Deeply nested paths
42+
print("Test 3: Deeply nested paths")
43+
store._store_dict = {
44+
'a/b/c/d': buffer_cls.from_bytes(b''),
45+
'a/b/c/e': buffer_cls.from_bytes(b''),
46+
'a/b/x/f': buffer_cls.from_bytes(b''),
47+
}
48+
result_a = sorted([k async for k in store.list_prefix("a")])
49+
result_ab = sorted([k async for k in store.list_prefix("a/b")])
50+
result_abc = sorted([k async for k in store.list_prefix("a/b/c")])
51+
print(f" Keys: {sorted(store._store_dict.keys())}")
52+
print(f" list_prefix('a'): {result_a}")
53+
print(f" list_prefix('a/b'): {result_ab}")
54+
print(f" list_prefix('a/b/c'): {result_abc}")
55+
assert result_a == ['a/b/c/d', 'a/b/c/e', 'a/b/x/f']
56+
assert result_ab == ['a/b/c/d', 'a/b/c/e', 'a/b/x/f']
57+
assert result_abc == ['a/b/c/d', 'a/b/c/e']
58+
print(" ✓ Deeply nested paths work correctly\n")
59+
60+
# Test case 4: Special characters in prefix
61+
print("Test 4: Special characters in prefix")
62+
store._store_dict = {
63+
'arr[0]/data': buffer_cls.from_bytes(b''),
64+
'arr/data': buffer_cls.from_bytes(b''),
65+
}
66+
result = sorted([k async for k in store.list_prefix("arr[")])
67+
print(f" Keys: {sorted(store._store_dict.keys())}")
68+
print(f" list_prefix('arr['): {result}")
69+
assert result == ['arr[0]/data'], f"Expected ['arr[0]/data'], got {result}"
70+
print(" ✓ Special characters in prefix work correctly\n")
71+
72+
# Test case 5: Issue #3773 - prefix matching should be directory-aware
73+
print("Test 5: Issue #3773 - Directory-aware prefix matching")
74+
store._store_dict = {
75+
'0/a': buffer_cls.from_bytes(b''),
76+
'0/b': buffer_cls.from_bytes(b''),
77+
'0_c/d': buffer_cls.from_bytes(b''),
78+
'1/e': buffer_cls.from_bytes(b''),
79+
}
80+
result_0 = sorted([k async for k in store.list_prefix('0')])
81+
result_0_c = sorted([k async for k in store.list_prefix('0_c')])
82+
print(f" Keys: {sorted(store._store_dict.keys())}")
83+
print(f" list_prefix('0'): {result_0}")
84+
print(f" list_prefix('0_c'): {result_0_c}")
85+
assert result_0 == ['0/a', '0/b'], f"'0' should NOT match '0_c/', got {result_0}"
86+
assert result_0_c == ['0_c/d'], f"'0_c' should match '0_c/', got {result_0_c}"
87+
print(" ✓ Issue #3773 is fixed - directory-aware matching works\n")
88+
89+
print("=== All edge cases passed! ===\n")
90+
91+
asyncio.run(test_edge_cases())

0 commit comments

Comments
 (0)