allow single codec instances for filters, and None for filters / compressor, and condense some tests

Author: d-v-b

src/zarr/core/array.py

@@ -3505,12 +3505,14 @@ def _get_default_codecs(
     | Iterable[numcodecs.abc.Codec]
     | numcodecs.abc.Codec
     | Literal["auto"]
+    | None
 )
 CompressorsParam: TypeAlias = (
     Iterable[dict[str, JSON] | BytesBytesCodec]
     | BytesBytesCodec
     | numcodecs.abc.Codec
     | Literal["auto"]
+    | None
 )
 
 
@@ -3646,6 +3648,7 @@ async def create_array(
         filters_parsed, compressor_parsed = _parse_chunk_encoding_v2(
             compressor=compressors, filters=filters, dtype=np.dtype(dtype)
         )
+
         if dimension_names is not None:
             raise ValueError("Zarr v2 arrays do not support dimension names.")
         if order is None:
@@ -3801,26 +3804,32 @@ def _parse_chunk_encoding_v2(
     """
     default_filters, default_compressor = _get_default_chunk_encoding_v2(dtype)
 
-    _filters: tuple[numcodecs.abc.Codec, ...] | None = None
-    _compressor: numcodecs.abc.Codec | None = None
+    _filters: tuple[numcodecs.abc.Codec, ...] | None
+    _compressor: numcodecs.abc.Codec | None
 
-    if compressor == "auto":
+    if compressor is None:
+        _compressor = None
+    elif compressor == "auto":
         _compressor = default_compressor
     else:
         if isinstance(compressor, Iterable) and not isinstance(compressor, dict):
             msg = f"For Zarr v2 arrays, the `compressor` must be a single codec. Got an iterable with type {type(compressor)} instead."
             raise TypeError(msg)
         _compressor = parse_compressor(compressor)
 
-    if filters == "auto":
+    if filters is None:
+        _filters = None
+    elif filters == "auto":
         _filters = default_filters
     else:
-        if isinstance(filters, Iterable) and not all(
-            isinstance(f, numcodecs.abc.Codec) for f in filters
-        ):
-            raise TypeError(
-                "For Zarr v2 arrays, all elements of `filters` must be numcodecs codecs."
-            )
+        if isinstance(filters, Iterable):
+            for idx, f in enumerate(filters):
+                if not isinstance(f, numcodecs.abc.Codec):
+                    msg = (
+                        "For Zarr v2 arrays, all elements of `filters` must be numcodecs codecs. "
+                        f"Element at index {idx} has type {type(f)}, which is not a numcodecs codec."
+                    )
+                    raise TypeError(msg)
         _filters = parse_filters(filters)
 
     return _filters, _compressor
@@ -3840,18 +3849,24 @@ def _parse_chunk_encoding_v3(
     )
     maybe_bytes_bytes: Iterable[Codec | dict[str, JSON]]
     maybe_array_array: Iterable[Codec | dict[str, JSON]]
+    out_bytes_bytes: tuple[BytesBytesCodec, ...]
+    if compressors is None:
+        out_bytes_bytes = ()
 
-    if compressors == "auto":
+    elif compressors == "auto":
         out_bytes_bytes = default_bytes_bytes
+
     else:
         if isinstance(compressors, dict | Codec):
             maybe_bytes_bytes = (compressors,)
         else:
             maybe_bytes_bytes = cast(Iterable[Codec | dict[str, JSON]], compressors)
 
         out_bytes_bytes = tuple(_parse_bytes_bytes_codec(c) for c in maybe_bytes_bytes)
-
-    if filters == "auto":
+    out_array_array: tuple[ArrayArrayCodec, ...]
+    if filters is None:
+        out_array_array = ()
+    elif filters == "auto":
         out_array_array = default_array_array
     else:
         if isinstance(filters, dict | Codec):

src/zarr/core/metadata/v2.py

@@ -241,6 +241,9 @@ def parse_filters(data: object) -> tuple[numcodecs.abc.Codec, ...] | None:
                 msg = f"Invalid filter at index {idx}. Expected a numcodecs.abc.Codec or a dict representation of numcodecs.abc.Codec. Got {type(val)} instead."
                 raise TypeError(msg)
         return tuple(out)
+    # take a single codec instance and wrap it in a tuple
+    if isinstance(data, numcodecs.abc.Codec):
+        return (data,)
     msg = f"Invalid filters. Expected None, an iterable of numcodecs.abc.Codec or dict representations of numcodecs.abc.Codec. Got {type(data)} instead."
     raise TypeError(msg)
 

tests/test_array.py

@@ -26,6 +26,7 @@
     FiltersParam,
     _get_default_chunk_encoding_v2,
     _get_default_chunk_encoding_v3,
+    _parse_chunk_encoding_v2,
     _parse_chunk_encoding_v3,
     chunks_initialized,
     create_array,
@@ -1002,43 +1003,26 @@ async def test_create_array_no_filters_compressors(
 
 
 @pytest.mark.parametrize("store", ["memory"], indirect=True)
+@pytest.mark.parametrize("dtype", ["uint8", "float32", "str"])
 @pytest.mark.parametrize(
     "compressors",
     [
         "auto",
+        None,
+        (),
         (ZstdCodec(level=3),),
         (ZstdCodec(level=3), GzipCodec(level=0)),
         ZstdCodec(level=3),
         {"name": "zstd", "configuration": {"level": 3}},
         ({"name": "zstd", "configuration": {"level": 3}},),
     ],
 )
-async def test_create_array_v3_compressors(
-    store: MemoryStore, compressors: CompressorsParam
-) -> None:
-    """
-    Test various possibilities for the compressors parameter to create_array
-    """
-    dtype = "uint8"
-    arr = await create_array(
-        store=store,
-        dtype=dtype,
-        shape=(10,),
-        zarr_format=3,
-        compressors=compressors,
-    )
-    _, _, bb_codecs_expected = _parse_chunk_encoding_v3(
-        filters=(), compressors=compressors, dtype=np.dtype(dtype)
-    )
-    # TODO: find a better way to get the compressors from the array.
-    assert arr.codec_pipeline.bytes_bytes_codecs == bb_codecs_expected  # type: ignore[attr-defined]
-
-
-@pytest.mark.parametrize("store", ["memory"], indirect=True)
 @pytest.mark.parametrize(
     "filters",
     [
         "auto",
+        None,
+        (),
         (
             TransposeCodec(
                 order=[
@@ -1067,23 +1051,58 @@ async def test_create_array_v3_compressors(
         ({"name": "transpose", "configuration": {"order": [0]}},),
     ],
 )
-async def test_create_array_v3_filters(store: MemoryStore, filters: FiltersParam) -> None:
+async def test_create_array_v3_chunk_encoding(
+    store: MemoryStore, compressors: CompressorsParam, filters: FiltersParam, dtype: str
+) -> None:
     """
-    Test various possibilities for the filters parameter to create_array
+    Test various possibilities for the compressors and filters parameter to create_array
     """
-    dtype = "uint8"
     arr = await create_array(
         store=store,
         dtype=dtype,
         shape=(10,),
         zarr_format=3,
         filters=filters,
+        compressors=compressors,
     )
-    aa_codecs_expected, _, _ = _parse_chunk_encoding_v3(
-        filters=filters, compressors=(), dtype=np.dtype(dtype)
+    aa_codecs_expected, _, bb_codecs_expected = _parse_chunk_encoding_v3(
+        filters=filters, compressors=compressors, dtype=np.dtype(dtype)
     )
-    # TODO: find a better way to get the filters from the array.
+    # TODO: find a better way to get the filters / compressors from the array.
     assert arr.codec_pipeline.array_array_codecs == aa_codecs_expected  # type: ignore[attr-defined]
+    assert arr.codec_pipeline.bytes_bytes_codecs == bb_codecs_expected  # type: ignore[attr-defined]
+
+
+@pytest.mark.parametrize("store", ["memory"], indirect=True)
+@pytest.mark.parametrize("dtype", ["uint8", "float32", "str"])
+@pytest.mark.parametrize(
+    "compressors",
+    [
+        "auto",
+        None,
+        numcodecs.Zstd(level=3),
+    ],
+)
+@pytest.mark.parametrize(
+    "filters", ["auto", None, numcodecs.GZip(level=1), (numcodecs.GZip(level=1),)]
+)
+async def test_create_array_v2_chunk_encoding(
+    store: MemoryStore, compressors: CompressorsParam, filters: FiltersParam, dtype: str
+) -> None:
+    arr = await create_array(
+        store=store,
+        dtype=dtype,
+        shape=(10,),
+        zarr_format=2,
+        compressors=compressors,
+        filters=filters,
+    )
+    filters_expected, compressor_expected = _parse_chunk_encoding_v2(
+        filters=filters, compressor=compressors, dtype=np.dtype(dtype)
+    )
+    # TODO: find a better way to get the filters/compressor from the array.
+    assert arr.metadata.compressor == compressor_expected  # type: ignore[union-attr]
+    assert arr.metadata.filters == filters_expected  # type: ignore[union-attr]
 
 
 @pytest.mark.parametrize("store", ["memory"], indirect=True)