apply Joe's suggestions

src/zarr/codecs/vlen_utf8.py

@@ -9,8 +9,8 @@
 from zarr.abc.codec import ArrayBytesCodec
 from zarr.core.buffer import Buffer, NDBuffer
 from zarr.core.common import JSON, parse_named_configuration
+from zarr.core.strings import cast_to_string_dtype
 from zarr.registry import register_codec
-from zarr.strings import cast_to_string_dtype
 
 if TYPE_CHECKING:
     from typing import Self
@@ -47,7 +47,7 @@ async def _decode_single(
         assert isinstance(chunk_bytes, Buffer)
 
         raw_bytes = chunk_bytes.as_array_like()
-        decoded = vlen_utf8_codec.decode(raw_bytes)
+        decoded = _vlen_utf8_codec.decode(raw_bytes)
         assert decoded.dtype == np.object_
         decoded.shape = chunk_spec.shape
         # coming out of the code, we know this is safe, so don't issue a warning
@@ -61,7 +61,7 @@ async def _encode_single(
     ) -> Buffer | None:
         assert isinstance(chunk_array, NDBuffer)
         return chunk_spec.prototype.buffer.from_bytes(
-            vlen_utf8_codec.encode(chunk_array.as_numpy_array())
+            _vlen_utf8_codec.encode(chunk_array.as_numpy_array())
         )
 
     def compute_encoded_size(self, input_byte_length: int, _chunk_spec: ArraySpec) -> int:
@@ -93,7 +93,7 @@ async def _decode_single(
         assert isinstance(chunk_bytes, Buffer)
 
         raw_bytes = chunk_bytes.as_array_like()
-        decoded = vlen_bytes_codec.decode(raw_bytes)
+        decoded = _vlen_bytes_codec.decode(raw_bytes)
         assert decoded.dtype == np.object_
         decoded.shape = chunk_spec.shape
         return chunk_spec.prototype.nd_buffer.from_numpy_array(decoded)
@@ -105,7 +105,7 @@ async def _encode_single(
     ) -> Buffer | None:
         assert isinstance(chunk_array, NDBuffer)
         return chunk_spec.prototype.buffer.from_bytes(
-            vlen_bytes_codec.encode(chunk_array.as_numpy_array())
+            _vlen_bytes_codec.encode(chunk_array.as_numpy_array())
         )
 
     def compute_encoded_size(self, input_byte_length: int, _chunk_spec: ArraySpec) -> int:

src/zarr/core/array.py

@@ -11,7 +11,7 @@
 
 from zarr._compat import _deprecate_positional_args
 from zarr.abc.store import Store, set_or_delete
-from zarr.codecs import get_default_array_bytes_codec
+from zarr.codecs import _get_default_array_bytes_codec
 from zarr.codecs._v2 import V2Compressor, V2Filters
 from zarr.core.attributes import Attributes
 from zarr.core.buffer import (
@@ -319,7 +319,9 @@ async def _create_v3(
 
         shape = parse_shapelike(shape)
         codecs = (
-            list(codecs) if codecs is not None else [get_default_array_bytes_codec(np.dtype(dtype))]
+            list(codecs)
+            if codecs is not None
+            else [_get_default_array_bytes_codec(np.dtype(dtype))]
         )
 
         if chunk_key_encoding is None:

src/zarr/core/metadata/v3.py

@@ -28,8 +28,8 @@
 from zarr.core.common import ZARR_JSON, parse_named_configuration, parse_shapelike
 from zarr.core.config import config
 from zarr.core.metadata.common import ArrayMetadata, parse_attributes
+from zarr.core.strings import STRING_DTYPE as STRING_NP_DTYPE
 from zarr.registry import get_codec_class
-from zarr.strings import STRING_DTYPE as STRING_NP_DTYPE
 
 DEFAULT_DTYPE = "float64"
 

tests/test_strings.py

@@ -3,7 +3,7 @@
 import numpy as np
 import pytest
 
-from zarr.strings import NUMPY_SUPPORTS_VLEN_STRING, STRING_DTYPE, cast_to_string_dtype
+from zarr.core.strings import NUMPY_SUPPORTS_VLEN_STRING, STRING_DTYPE, cast_to_string_dtype
 
 
 def test_string_defaults() -> None:

tests/v3/test_array.py

@@ -8,7 +8,7 @@
 import zarr.api.asynchronous
 import zarr.storage
 from zarr import Array, AsyncArray, Group
-from zarr.codecs.bytes import BytesCodec
+from zarr.codecs import BytesCodec, VLenBytesCodec
 from zarr.core.array import chunks_initialized
 from zarr.core.buffer.cpu import NDBuffer
 from zarr.core.common import JSON, ZarrFormat
@@ -370,3 +370,39 @@ def test_chunks_initialized(test_cls: type[Array] | type[AsyncArray]) -> None:
 
         expected = sorted(keys)
         assert observed == expected
+
+
+def test_default_fill_values() -> None:
+    a = Array.create(MemoryStore({}, mode="w"), shape=5, chunk_shape=5, dtype="<U4")
+    assert a.fill_value == ""
+
+    b = Array.create(MemoryStore({}, mode="w"), shape=5, chunk_shape=5, dtype="<S4")
+    assert b.fill_value == b""
+
+    c = Array.create(MemoryStore({}, mode="w"), shape=5, chunk_shape=5, dtype="i")
+    assert c.fill_value == 0
+
+    d = Array.create(MemoryStore({}, mode="w"), shape=5, chunk_shape=5, dtype="f")
+    assert d.fill_value == 0.0
+
+
+def test_vlen_errors() -> None:
+    with pytest.raises(ValueError, match="At least one ArrayBytesCodec is required."):
+        Array.create(MemoryStore({}, mode="w"), shape=5, chunk_shape=5, dtype="<U4", codecs=[])
+
+    with pytest.raises(
+        ValueError,
+        match="For string dtype, ArrayBytesCodec must be `VLenUTF8Codec`, got `BytesCodec`.",
+    ):
+        Array.create(
+            MemoryStore({}, mode="w"), shape=5, chunk_shape=5, dtype="<U4", codecs=[BytesCodec()]
+        )
+
+    with pytest.raises(ValueError, match="Only one ArrayBytesCodec is allowed."):
+        Array.create(
+            MemoryStore({}, mode="w"),
+            shape=5,
+            chunk_shape=5,
+            dtype="<U4",
+            codecs=[BytesCodec(), VLenBytesCodec()],
+        )

tests/v3/test_codecs/test_vlen.py

@@ -6,10 +6,10 @@
 from zarr import Array
 from zarr.abc.codec import Codec
 from zarr.abc.store import Store
-from zarr.codecs import BytesCodec, VLenBytesCodec, VLenUTF8Codec, ZstdCodec
+from zarr.codecs import VLenBytesCodec, VLenUTF8Codec, ZstdCodec
 from zarr.core.metadata.v3 import ArrayV3Metadata, DataType
+from zarr.core.strings import NUMPY_SUPPORTS_VLEN_STRING
 from zarr.storage.common import StorePath
-from zarr.strings import NUMPY_SUPPORTS_VLEN_STRING
 
 numpy_str_dtypes: list[type | None] = [None, str, np.dtypes.StrDType]
 expected_zarr_string_dtype: np.dtype[Any]
@@ -93,36 +93,3 @@ def test_vlen_bytes(store: Store, as_object_array: bool, codecs: None | list[Cod
     assert np.array_equal(data, b[:, :])
     assert b.metadata.data_type == DataType.bytes
     assert a.dtype == "O"
-
-
-# TODO: move these tests out of codecs and into a more appropriate location
-@pytest.mark.parametrize("store", ["memory"], indirect=["store"])
-def test_default_fill_values(store: Store) -> None:
-    a = Array.create(StorePath(store, path="string"), shape=5, chunk_shape=5, dtype="<U4")
-    assert a.fill_value == ""
-
-    b = Array.create(StorePath(store, path="bytes"), shape=5, chunk_shape=5, dtype="<S4")
-    assert b.fill_value == b""
-
-
-@pytest.mark.parametrize("store", ["memory"], indirect=["store"])
-def test_vlen_errors(store: Store) -> None:
-    with pytest.raises(ValueError, match="At least one ArrayBytesCodec is required."):
-        Array.create(StorePath(store, path="a"), shape=5, chunk_shape=5, dtype="<U4", codecs=[])
-
-    with pytest.raises(
-        ValueError,
-        match="For string dtype, ArrayBytesCodec must be `VLenUTF8Codec`, got `BytesCodec`.",
-    ):
-        Array.create(
-            StorePath(store, path="b"), shape=5, chunk_shape=5, dtype="<U4", codecs=[BytesCodec()]
-        )
-
-    with pytest.raises(ValueError, match="Only one ArrayBytesCodec is allowed."):
-        Array.create(
-            StorePath(store, path="b"),
-            shape=5,
-            chunk_shape=5,
-            dtype="<U4",
-            codecs=[BytesCodec(), VLenBytesCodec()],
-        )