recover from bad rebase

Author: d-v-b

src/zarr/abc/codec.py

@@ -22,7 +22,7 @@
     from collections.abc import Awaitable, Callable, Iterable
     from typing import Self
 
-    from zarr.abc.store import ByteGetter, ByteSetter
+    from zarr.abc.store import ByteGetter, ByteSetter, Store
     from zarr.core.array_spec import ArraySpec
     from zarr.core.chunk_grids import ChunkGrid
     from zarr.core.dtype.wrapper import TBaseDType, TBaseScalar, ZDType

src/zarr/api/asynchronous.py

@@ -9,14 +9,17 @@
 import numpy.typing as npt
 from typing_extensions import deprecated
 
+from zarr.abc.store import Store
 from zarr.core.array import (
+    DEFAULT_FILL_VALUE,
     Array,
     AsyncArray,
-    _get_default_chunk_encoding_v2,
+    CompressorLike,
     create_array,
+    from_array,
     get_array_metadata,
 )
-from zarr.core.array_spec import ArrayConfig, ArrayConfigLike, ArrayConfigParams
+from zarr.core.array_spec import ArrayConfigLike, parse_array_config
 from zarr.core.buffer import NDArrayLike
 from zarr.core.common import (
     JSON,
@@ -28,15 +31,16 @@
     _default_zarr_format,
     _warn_write_empty_chunks_kwarg,
 )
-from zarr.core.dtype import ZDTypeLike, get_data_type_from_native_dtype, parse_data_type
+from zarr.core.dtype import ZDTypeLike, get_data_type_from_native_dtype
 from zarr.core.group import (
     AsyncGroup,
     ConsolidatedMetadata,
     GroupMetadata,
     create_hierarchy,
 )
 from zarr.core.metadata import ArrayMetadataDict, ArrayV2Metadata, ArrayV3Metadata
-from zarr.errors import NodeTypeValidationError
+from zarr.errors import GroupNotFoundError, NodeTypeValidationError
+from zarr.storage import StorePath
 from zarr.storage._common import make_store_path
 
 if TYPE_CHECKING:
@@ -857,7 +861,7 @@ async def open_group(
 async def create(
     shape: ChunkCoords | int,
     *,  # Note: this is a change from v2
-    chunks: ChunkCoords | int | None = None,  # TODO: v2 allowed chunks=True
+    chunks: ChunkCoords | int | bool | None = None,
     dtype: ZDTypeLike | None = None,
     compressor: CompressorLike = "auto",
     fill_value: Any | None = DEFAULT_FILL_VALUE,
@@ -1005,21 +1009,6 @@ async def create(
         _handle_zarr_version_or_format(zarr_version=zarr_version, zarr_format=zarr_format)
         or _default_zarr_format()
     )
-    zdtype = parse_data_type(dtype, zarr_format=zarr_format)
-    if zarr_format == 2:
-        if chunks is None:
-            chunks = shape
-        default_filters, default_compressor = _get_default_chunk_encoding_v2(zdtype)
-        if not filters:
-            filters = default_filters  # type: ignore[assignment]
-        if compressor is None:
-            compressor = default_compressor
-    elif zarr_format == 3 and chunk_shape is None:  # type: ignore[redundant-expr]
-        if chunks is not None:
-            chunk_shape = chunks
-            chunks = None
-        else:
-            chunk_shape = shape
 
     if synchronizer is not None:
         warnings.warn("synchronizer is not yet implemented", RuntimeWarning, stacklevel=2)
@@ -1060,7 +1049,7 @@ async def create(
         store_path,
         shape=shape,
         chunks=chunks,
-        dtype=zdtype,
+        dtype=dtype,
         compressor=compressor,
         fill_value=fill_value,
         overwrite=overwrite,

src/zarr/api/synchronous.py

@@ -602,7 +602,7 @@ def create(
     chunks: ChunkCoords | int | bool | None = None,
     dtype: ZDTypeLike | None = None,
     compressor: CompressorLike = "auto",
-    fill_value: Any | None = None,  # TODO: need type
+    fill_value: Any | None = DEFAULT_FILL_VALUE,  # TODO: need type
     order: MemoryOrder | None = None,
     store: str | StoreLike | None = None,
     synchronizer: Any | None = None,

src/zarr/codecs/blosc.py

@@ -3,7 +3,6 @@
 import asyncio
 from collections.abc import Mapping
 from dataclasses import dataclass, replace
-from enum import Enum
 from functools import cached_property
 from typing import TYPE_CHECKING, Final, Literal, NotRequired, TypedDict, TypeGuard, overload
 
@@ -17,7 +16,6 @@
     JSON,
     NamedRequiredConfig,
     ZarrFormat,
-    parse_named_configuration,
 )
 from zarr.core.dtype.common import HasItemSize
 from zarr.registry import register_codec
@@ -42,18 +40,21 @@ class BloscConfigV2(TypedDict):
     blocksize: int
     typesize: NotRequired[int]
 
+
 class BloscConfigV3(TypedDict):
     cname: BloscCname
     clevel: int
     shuffle: BloscShuffle
     blocksize: int
     typesize: int
 
+
 class BloscJSON_V2(CodecJSON_V2[Literal["blosc"]], BloscConfigV2):
     """
     The JSON form of the Blosc codec in Zarr V2.
     """
 
+
 class BloscJSON_V3(NamedRequiredConfig[Literal["blosc"], BloscConfigV3]):
     """
     The JSON form of the Blosc codec in Zarr V3.
@@ -81,11 +82,10 @@ def check_json_v3(data: CodecJSON) -> TypeGuard[BloscJSON_V3]:
 
 def parse_cname(value: object) -> BloscCname:
     if value not in BLOSC_CNAME:
-        raise ValueError(
-            f"Value must be one of {BLOSC_CNAME}. Got {value} instead."
-        )
+        raise ValueError(f"Value must be one of {BLOSC_CNAME}. Got {value} instead.")
     return value
 
+
 # See https://zarr.readthedocs.io/en/stable/user-guide/performance.html#configuring-blosc
 numcodecs.blosc.use_threads = False
 
@@ -154,21 +154,9 @@ def __init__(
     @classmethod
     def from_dict(cls, data: dict[str, JSON]) -> Self:
         return cls.from_json(data, zarr_format=3)
-        _, configuration_parsed = parse_named_configuration(data, "blosc")
-        return cls(**configuration_parsed)  # type: ignore[arg-type]
 
     def to_dict(self) -> dict[str, JSON]:
         return self.to_json(zarr_format=3)
-        return {
-            "name": "blosc",
-            "configuration": {
-                "typesize": self.typesize,
-                "cname": self.cname,
-                "clevel": self.clevel,
-                "shuffle": self.shuffle,
-                "blocksize": self.blocksize,
-            },
-        }
 
     @classmethod
     def _from_json_v2(cls, data: CodecJSON) -> Self:
@@ -213,22 +201,23 @@ def to_json(self, zarr_format: ZarrFormat) -> BloscJSON_V2 | BloscJSON_V3:
             raise ValueError("typesize and blocksize need to be set for encoding.")
         if zarr_format == 2:
             return {
-                "id": "blosc", 
+                "id": "blosc",
                 "clevel": self.clevel,
                 "cname": self.cname,
                 "shuffle": BLOSC_SHUFFLE.index(self.shuffle),
-                "blocksize": self.blocksize
-                }
+                "blocksize": self.blocksize,
+            }
         elif zarr_format == 3:
             return {
-                "name": "blosc", 
+                "name": "blosc",
                 "configuration": {
                     "clevel": self.clevel,
                     "cname": self.cname,
                     "shuffle": self.shuffle,
                     "typesize": self.typesize,
-                    "blocksize": self.blocksize
-                    }}
+                    "blocksize": self.blocksize,
+                },
+            }
         raise ValueError(
             f"Unsupported Zarr format {zarr_format}. Expected 2 or 3."
         )  # pragma: no cover
@@ -241,10 +230,7 @@ def evolve_from_array_spec(self, array_spec: ArraySpec) -> Self:
         if new_codec.typesize is None:
             new_codec = replace(new_codec, typesize=item_size)
         if new_codec.shuffle is None:
-            new_codec = replace(
-                new_codec,
-                shuffle="bitshuffle" if item_size == 1 else "shuffle"),
-            )
+            new_codec = replace(new_codec, shuffle="bitshuffle" if item_size == 1 else "shuffle")
 
         return new_codec
 

src/zarr/codecs/bytes.py

@@ -12,7 +12,6 @@
 from zarr.core.buffer import Buffer, NDArrayLike, NDBuffer
 from zarr.core.common import JSON, NamedConfig, ZarrFormat
 from zarr.core.dtype.common import HasEndianness
-from zarr.core.dtype.npy.common import endianness_to_numpy_str
 from zarr.registry import register_codec
 
 if TYPE_CHECKING:

src/zarr/codecs/gzip.py

@@ -36,6 +36,7 @@ def parse_gzip_level(data: JSON) -> int:
 class GZipConfig(TypedDict):
     level: int
 
+
 class GZipJSON_V2(CodecJSON_V2[Literal["gzip"]], GZipConfig):
     """
     The JSON form of the GZip codec in Zarr V2.

src/zarr/codecs/numcodec.py

@@ -6,10 +6,8 @@
 
 import asyncio
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Callable, Literal, Self, TypeGuard, overload
+from typing import TYPE_CHECKING, Literal, Self, TypeGuard, overload
 
-import numcodecs
-import numcodecs.registry as numcodecs_registry
 import numpy as np
 from typing_extensions import Protocol, runtime_checkable
 
@@ -31,6 +29,7 @@
 
 BufferOrNDArray = Buffer | np.ndarray[tuple[int, ...], np.dtype[np.generic]] | NDArrayLike
 
+
 def get_numcodec_class(name: str) -> type[Numcodec]:
     """Obtain a numcodec codec class by name.
 
@@ -52,6 +51,8 @@ def get_numcodec_class(name: str) -> type[Numcodec]:
     Zlib(level=1)
 
     """
+    import numcodecs.registry as numcodecs_registry
+
     cls = numcodecs_registry.codec_registry.get(name)
     if cls is None and name in numcodecs_registry.entries:
         cls = numcodecs_registry.entries[name].load()
@@ -60,9 +61,6 @@ def get_numcodec_class(name: str) -> type[Numcodec]:
         return cls
     raise KeyError(name)
 
-def resolve_numcodec(config: CodecJSON_V2[str]) -> Numcodec:
-    return numcodecs.get_codec(config)  # type: ignore[no-any-return]
-
 
 @runtime_checkable
 class Numcodec(Protocol):
@@ -83,25 +81,26 @@ def get_config(self) -> CodecJSON_V2[str]: ...
     @classmethod
     def from_config(cls, config: CodecJSON_V2[str]) -> Self: ...
 
+
 def is_numcodec_cls(obj: object) -> TypeGuard[type[Numcodec]]:
     """
     Check if the given object implements the Numcodec protocol. Because the @runtime_checkable
     decorator does not allow issubclass checks for protocols with non-method members (i.e., attributes),
     we need to manually check for the presence of the required attributes and methods.
     """
     return (
-        isinstance(obj, type) and
-        hasattr(obj, "codec_id") and
-        isinstance(obj.codec_id, str) and
-        hasattr(obj, "encode") and
-        callable(obj.encode) and
-        hasattr(obj, "decode") and
-        callable(obj.decode) and
-        hasattr(obj, "get_config") and
-        callable(obj.get_config) and
-        hasattr(obj, "from_config") and
-        callable(obj.from_config)
-        )
+        isinstance(obj, type)
+        and hasattr(obj, "codec_id")
+        and isinstance(obj.codec_id, str)
+        and hasattr(obj, "encode")
+        and callable(obj.encode)
+        and hasattr(obj, "decode")
+        and callable(obj.decode)
+        and hasattr(obj, "get_config")
+        and callable(obj.get_config)
+        and hasattr(obj, "from_config")
+        and callable(obj.from_config)
+    )
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -113,9 +112,7 @@ def to_json(self, zarr_format: Literal[2]) -> CodecJSON_V2[str]: ...
     @overload
     def to_json(self, zarr_format: Literal[3]) -> NamedConfig[str, BaseConfig]: ...
 
-    def to_json(
-        self, zarr_format: ZarrFormat
-    ) -> CodecJSON_V2[str] | NamedConfig[str, BaseConfig]:
+    def to_json(self, zarr_format: ZarrFormat) -> CodecJSON_V2[str] | NamedConfig[str, BaseConfig]:
         if zarr_format == 2:
             return self.codec.get_config()
         elif zarr_format == 3:
@@ -126,7 +123,9 @@ def to_json(
 
     @classmethod
     def _from_json_v2(cls, data: CodecJSON) -> Self:
-        return cls(codec=resolve_numcodec(data))  # type: ignore[arg-type]
+        raise NotADirectoryError(
+            "This class does not support creating instances from JSON data for Zarr format 2."
+            )
 
     @classmethod
     def _from_json_v3(cls, data: CodecJSON) -> Self:
@@ -137,7 +136,6 @@ def _from_json_v3(cls, data: CodecJSON) -> Self:
     def compute_encoded_size(self, input_byte_length: int, chunk_spec: ArraySpec) -> int:
         raise NotImplementedError
 
-
     def to_array_array(self) -> NumcodecsArrayArrayCodec:
         """
         Use the ``_codec`` attribute to create a NumcodecsArrayArrayCodec.

src/zarr/codecs/sharding.py

@@ -55,7 +55,6 @@
     ChunkCoordsLike,
     NamedRequiredConfig,
     parse_enum,
-    parse_named_configuration,
     parse_shapelike,
     product,
 )
@@ -453,8 +452,6 @@ def __setstate__(self, state: dict[str, Any]) -> None:
     @classmethod
     def from_dict(cls, data: dict[str, JSON]) -> Self:
         return cls.from_json(data, zarr_format=3)
-        _, configuration_parsed = parse_named_configuration(data, "sharding_indexed")
-        return cls(**configuration_parsed)  # type: ignore[arg-type]
 
     @classmethod
     def _from_json_v2(cls, data: CodecJSON) -> Self:
@@ -493,15 +490,6 @@ def codec_pipeline(self) -> CodecPipeline:
 
     def to_dict(self) -> dict[str, JSON]:
         return self.to_json(zarr_format=3)
-        return {
-            "name": "sharding_indexed",
-            "configuration": {
-                "chunk_shape": self.chunk_shape,
-                "codecs": tuple(s.to_dict() for s in self.codecs),
-                "index_codecs": tuple(s.to_dict() for s in self.index_codecs),
-                "index_location": self.index_location.value,
-            },
-        }
 
     @overload
     def to_json(self, zarr_format: Literal[2]) -> ShardingJSON_V2: ...