NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
PyPI · #1774 most downloaded on PyPI
An implementation of chunked, compressed, N-dimensional arrays for Python
Last release 19 days ago
15 Sep 2026
Ships fairly regularly
a new release about every 5 weeks
Nearly every release is documented
notes for 59 of the last 60 stable releases
8 versions withdrawn
withdrawn after publishing
11 years old
120 releases · first in 2015
zarr 3.4.0. Highlights are in the release blog post ; the full per-change list is in the release notes . This release adds a required dependency on ms
zarr 3.4.0. Highlights are in the release blog post; the full per-change list is in the release notes. This release adds a required dependency on msgspec>=0.19.
require_array to accept a ZDType by @JOhnsonKC201 in #4189Full Changelog: v3.3.0...v3.4.0
One column per quarter.
JSON metadata validation now delegates to msgspec.convert for the type
coercions it supports (Literal membership, int / bool strictness,
list-to-tuple), replacing the per-field hand-written parse_* logic.
User-defined attributes retain their existing JSON handling.
A latent generator-exhaustion bug in
parse_storage_transformers is also fixed. See #3285.
As a result some metadata inputs are now parsed more strictly. The previous
per-field checks compared values with ==, which accepts any numerically
equal object, so a float such as 2.0 was accepted as zarr_format; it is
now rejected because it is not an int. Booleans are likewise no longer
accepted where an int is expected, since bool is an int subclass.
Metadata that conforms to the Zarr specification is unaffected. (#4063)
zarr.registry.get_codec_class now raises zarr.errors.UnknownCodecError instead of KeyError
when no implementation is registered for a codec, and zarr.core.config.BadConfigError instead of
KeyError when the implementation named in config["codecs"][name] is not registered.
zarr.registry.get_numcodec raises UnknownCodecError instead of the ValueError numcodecs
raises for an unregistered Zarr format 2 codec id (numcodecs.errors.UnknownCodecError on
numcodecs 0.15.1 and later). All of these are subclasses of ValueError, so except ValueError
is unaffected, but except KeyError and except numcodecs.errors.UnknownCodecError are.
These errors now name Python packages known to provide the codec, so that a user who cannot read an array learns what to install:
An implementation for codec 'wavpack' is not available. Register one explicitly using the codec
registry (see ...), or install a Python package that registers a codec implementation with
numcodecs. Known packages supporting this codec: wavpack-numcodecs.
The tables covering this live in src/zarr/registry.py, one per Zarr format, and include the
codecs numcodecs gates behind its own optional dependencies (zfpy, pcodec, crc32c,
msgpack2). Codec authors can add their published package to them.
A codec whose from_dict raises KeyError on a malformed configuration now surfaces as
zarr.errors.MetadataValidationError naming the codec and the missing key. Previously it was
reported as UnknownCodecError: Unknown codec: '<configuration key>', presenting a configuration
key as though it were a codec name, and on the zarr.open path a bare KeyError could be
swallowed by the array-then-group fallback and reported as an unrelated group error.
zarr.errors.UnknownCodecError is now exported from zarr.errors. (#4277)
zarr.create_array, Group.create_array, zarr.from_array, and the entry points built on them now accept a numpy array as the chunks or shards specification, alongside ints, tuples, and numpy integer scalars. This is new for that API: it has never accepted numpy arrays in any 3.x release, because each entry point compared the specification to the "auto" or "keep" sentinel string before normalizing it, and for a numpy array that comparison raised numpy's ambiguous-truth-value ValueError. Those sentinel checks are now guarded so array-like specifications reach the normalizer, bringing this API in line with the legacy zarr.create / zarr.array / zarr.open_array functions, which have accepted numpy arrays since 2.x. (#4329)
Array creation is now O(1) in the number of chunks per dimension. Chunk
normalization returns a ChunkGrid whose uniform dimensions are stored as a
size + extent pair (FixedDimension) instead of being expanded to one entry
per chunk, so creating arrays like
zarr.create_array(store, shape=(2**62,), chunks=(1,), dtype='int32') succeeds
instantly instead of raising ValueError or allocating gigabytes of memory.
The intermediate ChunksTuple representation was removed in the process, and
ChunksLike now admits per-dimension specs that mix a bare int (uniform chunk
size) with explicit edge-length sequences, matching what the normalizer and
the rectilinear grid spec already accepted.
This fixes the array-creation half of #4174; the coordinate-selection
allocation reported there is still tracked in that issue (#4172 fixed the
related case of sorted 1-D coordinate selections). (#4218)
Allow Group.require_array to accept a ZDType for dtype, matching the other array creation methods. Previously an existing array could only be required with a string or NumPy dtype. (#4189)
Consolidated metadata is now reconstructed independently of the order the keys appear in on disk. Previously, sibling subtrees whose keys were not adjacent in the persisted mapping lost their children, which made nodes unreachable through consolidated metadata -- most visibly for sibling groups whose names differ only by case. (#4227)
FsspecStore.from_mapper and FsspecStore.from_url no longer fail when converting a synchronous instance of an async-capable filesystem whose storage options contain objects that cannot be serialized to JSON (e.g. an azure.identity.DefaultAzureCredential). The async instance is now constructed from the original filesystem arguments instead of a JSON round-trip. (#4239)
Numpy integers are accepted as chunk sizes again. Since 3.3.0 a per-dimension chunk size that was a numpy integer (e.g. chunks=(np.int64(2), np.int64(2)), as produced by any computed chunk shape) raised TypeError: 'numpy.int64' object is not iterable, because the scalar chunk path narrowed on int while its caller dispatched on numbers.Integral. The same regression had broken numpy arrays as chunk specifications through the legacy zarr.create / zarr.array / zarr.open_array functions, which accepted them in 2.x and 3.2.x; those work again. (zarr.create_array and the functions built on it gain numpy-array support separately, in #4329.) A chunk specification that is neither an integer nor iterable now reports the offending value instead of failing with an opaque iteration error. (#4257)
The cast_value codec now requires cast-value-rs>=0.4.2. Earlier versions of that backend silently corrupted data when handed an array that was not row-major — the layout the transpose codec produces — so a cast_value codec next to a transpose codec would either write transposed values with no error or fail with ValueError: Input array must be contiguous. The minimum version is enforced at runtime as well as in the package metadata, so an environment that already has an older cast-value-rs installed now raises ImportError when the codec is used, instead of corrupting data. (#4260)
Accept universal-pathlib UPath objects wherever
zarr accepts a StoreLike value. A remote UPath now creates an FsspecStore using the
filesystem and storage options the UPath already carries, and a local UPath creates a
LocalStore, so that UPath('/data') and Path('/data') behave the same.
Previously this worked only by accident: in universal-pathlib < 0.3 every UPath subclassed
pathlib.Path and implemented __fspath__, so remote paths were either converted to a URI string
by the caller or wrapped in a LocalStore that happened to dispatch through fsspec. Since
universal-pathlib 0.3 remote paths do neither, and passing one raised
TypeError: Unsupported type for store_like.
FsspecStore.from_upath also now converts the UPath's filesystem to async mode, instead of
raising TypeError for synchronous filesystems and warning for sync-mode instances of async ones. (#4265)
Explicit per-chunk size lists now always produce a rectilinear chunk grid,
even when the sizes happen to describe a regular grid (all equal, or all equal
with a smaller trailing chunk). Previously such input was silently collapsed to
a regular grid, which changed resize semantics: a regular grid grows by
extending the uniform pattern, while a rectilinear grid appends a new edge
chunk — the behavior an append-oriented layout like (168,) * 13 + (24,)
relies on. The grid kind now follows the input syntax, matching 3.2.x:
scalar chunk sizes (including numpy integers and the -1 sentinel) produce a
regular grid, nested sequences produce a rectilinear grid. Rectilinear grids
remain gated behind zarr.config.set({"array.rectilinear_chunks": True}).
See #4174 for the accompanying O(1) chunk normalization change.
One consequence for users who never enable rectilinear chunks: because a
nested sequence now always requests a rectilinear grid, a per-dimension
sequence of edge lengths that happens to be uniform — for example the
((4,), (4,)) or [[3, 3, 1]] form that a dask array's .chunks attribute
produces — is no longer quietly accepted as a regular grid when the
array.rectilinear_chunks option is off. Such input raises
ValueError: Rectilinear chunk grids are experimental and disabled by default,
exactly as it did in 3.2.x; the silent acceptance existed only in 3.3.0. Pass
one integer per dimension (e.g. chunks=(4, 4), or a dask array's
.chunksize) to request a regular grid.
zarr.from_array with the default chunks="keep" / shards="keep" now
reproduces the source's stored grid exactly: a rectilinear grid is passed
through in O(number of dimensions), with uniform dimensions keeping their
bare-int shorthand; sharding under a rectilinear shard grid is preserved
instead of being silently dropped; and the default write_data=True copy
works for every grid kind. Array.chunks is now defined for any sharded array
(the inner chunks of a shard are always regular), and for sharded arrays with
a rectilinear shard grid Array.info no longer raises — it reports the shard
shape as <variable> — while Array.nchunks_initialized counts the chunks of
each initialized shard individually instead of raising.
Apart from the nested-sequence input form noted above, everything described
here concerns rectilinear chunk grids, which remain an experimental feature
gated behind zarr.config.set({"array.rectilinear_chunks": True}); arrays
with regular chunk grids are unaffected. (#4218)
A scale_offset codec configured with a string-valued zero scale is now rejected. scale accepts strings, and no string is ever equal to 0, so "0", "0.0" and the hex form "0x0000000000000000" skipped the "scale must be non-zero" check that the numeric 0 triggers. On float data types the array was created, every chunk was written as zero and read back as nan with no error, and the zero scale was persisted to the metadata so reopening the store reproduced it; on integer data types the codec raised ZeroDivisionError instead of ValueError. The check now runs on the parsed scalar rather than the value as supplied. (#4279)
Fixed a ValueError when setting an orthogonal selection on a sharded array where more than one dimension is indexed by an array. The sharding codec re-derives an indexer from the chunk selection it is handed, which turns such a selection into a coordinate selection addressing the value buffer flat, so the write failed on a shape mismatch. Both partial-encode paths are fixed, so the write works under either codec pipeline. (#4284)
Fixed integer array indexing with unsigned index dtypes. An unsorted index such as
np.array([3, 0], dtype="uint8") spanning more than one chunk raised IndexError, because
the order check used np.diff, which wraps on unsigned dtypes and misclassified a
descending selection as increasing. Separately, a uint64 index raised IndexError on both
array[...] and array.vindex[...] — sorted or not — because uint64 promotes to
float64 against a signed chunk offset. Index arrays are now cast to intp.
Unsigned indices are bounds-checked before this conversion, so values such as
np.uint64(2**64 - 1) are rejected rather than wrapping to a negative index and
reading or overwriting an element at the end of the array.
Negative-index normalization copies indices before modifying them, preserving caller-owned arrays and supporting read-only index arrays. Reusing one index array across axes of different lengths now normalizes each axis independently. (#4286)
zarr.from_array now defaults to the fill value and the attributes of the source array. Previously both were silently discarded: the array was created with the data type's default scalar and no attributes.
An explicit fill_value=None now selects the data type's default scalar (Zarr format 3) or a null fill value (Zarr format 2), consistently with create_array, and an empty attributes dict creates the array with no attributes. (#4288)
Fixed an infinite loop when creating a 0-dimensional array with shards="auto" while the array.target_shard_size_bytes config option is set. Such arrays now resolve to shards=(), matching the behavior when no shard size target is configured. (#4305)
Fixed chunks=-1 on a zero-length axis resolving to an invalid chunk size of 0, which caused a ValueError, ZeroDivisionError, or infinite loop depending on the sharding configuration. Such axes now get chunk size 1, matching chunks="auto". (#4307)
Fixed a ValueError when setting an orthogonal selection on a sharded array that mixes an integer index with two or more array indices, such as a.oindex[[3, 1, 2], 1, [0, 2]] = value. The fix for the array-only case in #4284 reshaped the value only when its shape matched the coordinate selection exactly; the sharding codec now also ravels a value that is the selection's shape minus the integer-indexed axes. Values of any other rank are left alone, so a write that is invalid on an unsharded array fails the same way on a sharded one. Both partial-encode paths share one helper for this. (#4316)
Opening a Zarr format 3 array whose codec's from_dict raised a KeyError with no arguments used to fail with an unrelated IndexError: tuple index out of range while formatting the error message. Because that IndexError is not a ValueError, it also escaped the array-then-group fallback in zarr.open and broke group operations such as Group.members() and "child" in group when any child array used such a codec. The KeyError is now always reported as a MetadataValidationError naming the codec, with the offending key included only when the KeyError carried one. (#4324)
zarr.from_array now deep-copies the source array's attributes instead of sharing nested dicts and lists between the source and the new array. Previously, mutating a nested attribute on the new array (for example dst.attrs["meta"]["tags"].append(...)) silently changed the source array's in-memory attributes too. Deeply nested attributes can raise RecursionError during the copy even if they can be stored and reopened; the threshold depends on Python's recursion limit and call stack. Pass attributes={} to omit inherited attributes. (#4325)
Fixed chunks=False on a zero-length axis resolving to a chunk size of 0, which raised a ValueError for Zarr format 3, raised a ZeroDivisionError with shards="auto", and silently wrote invalid chunks metadata for Zarr format 2. False now takes the same path as chunks=-1, so such axes get chunk size 1, matching chunks="auto". (#4328)
from_array preserves a Zarr source's explicit data type instead of trying to infer it from its NumPy dtype, allowing variable-length bytes arrays to be copied. (#4335)
The documentation build and the documentation test suite no longer delete a data/ directory relative to the current working directory. Two executable docs sessions opened with shutil.rmtree('data', ignore_errors=True) to make their examples re-runnable; because executed docs blocks run in the process working directory rather than the docs tree, mkdocs build -f <repo>/mkdocs.yml or pytest tests/test_docs.py started from any directory containing a data/ folder — a project checkout, or / — silently emptied it. The sdist ships docs/ and tests/ and testpaths collects docs/user-guide, so this reached anyone running the shipped test suite, not only contributors. The deletions are gone; the on-disk examples in the quick start, arrays, groups, storage and performance guides now create with overwrite=True (or zarr.save_array(..., mode="w")), which is also what a reader re-running an example needs, and a new docs test rejects any executed block that calls a filesystem deletion. (#4339)
Missing Zarr format 3 imagecodecs now name imagecodecs-zarr as a known provider, alongside virtual-tiff where both packages register the codec. (#4351)
LocalStore now retries the rename that publishes a written file when Windows
reports the destination as transiently busy (ERROR_ACCESS_DENIED or
ERROR_SHARING_VIOLATION). Replacing a name that was itself replaced moments
earlier intermittently fails this way in a single process, which aborted
otherwise ordinary writes. The retry is bounded to well under a second, is a
no-op off Windows, and never retries the FileExistsError that the exclusive
path uses to report an existing node. This mitigates but does not fully resolve
#3522: a second process holding the destination open for longer than the retry
budget will still fail. Zarr v2 had the equivalent retry from #698 and it was
not carried over when atomic writes arrived in #3412. (#4358)
zarr.api.asynchronous,
zarr.api.synchronous, zarr.core.array, zarr.registry, and
zarr.storage._common. No functional changes. (#4193)zarr-metadata and zarr-indexing —
and linked it from the landing page. Links to those packages now use the
canonical https://zarr.readthedocs.io/projects/... URLs, and each companion
package's documentation links back to the zarr-python docs. (#4247)deprecate blosc enums by @d-v-b in #3963
default env so the uv installer is inherited by @lhoupert in #4023BytesCodec by @keewis in #3417Note truncated.
Optimizes reading multiple chunks from a shard. Serial calls to Store.get()
in the sharding codec have been replaced with a single call to
Store.get_ranges(), which coalesces nearby byte ranges and fetches them
concurrently. (#3004)
Added a subchunk_write_order option to ShardingCodec to control the physical order of subchunks within a shard. Supported values are morton, unordered, lexicographic, and colexicographic. unordered makes no guarantee about subchunk layout. This setting affects only on-disk layout, not the data read back, and is not persisted in array metadata: it applies per codec instance and is not recovered when reopening a sharded array. (#3826)
Added SyncByteGetter and SyncByteSetter runtime-checkable protocols and a get_ranges_sync method on the Store ABC. These let custom byte getters/setters opt into the synchronous codec pipeline's fast path for in-memory IO, which the sharding codec uses for its inner chunks. (#3885)
Added FusedCodecPipeline, an opt-in codec pipeline that runs codec compute synchronously and in bulk (avoiding the per-chunk async scheduling overhead of the default BatchedCodecPipeline), giving large speedups for sharded arrays. The default BatchedCodecPipeline is unchanged for standard configurations, so existing code keeps working unless you opt in; enable the new pipeline with zarr.config.set({"codec_pipeline.path": "zarr.core.codec_pipeline.FusedCodecPipeline"}). (#3885)
Add zarr.abc.store.Store.get_ranges for concurrent, coalesced multi-range reads from a single key. The method is defined on the Store ABC with a default implementation built on Store.get, so every store inherits a working version; stores with native multi-range backends (e.g. FsspecStore) can override for efficiency. Coalescing knobs (max_concurrency, max_gap_bytes, max_coalesced_bytes) are passed as keyword arguments to get_ranges. Failures from underlying fetches surface as a BaseExceptionGroup (PEP 654); callers should use except* to filter for specific exception types such as FileNotFoundError. (#3925)
Two new fields on ArrayConfig control how the sharding codec coalesces partial-shard reads: sharding_coalesce_max_gap_bytes (default 1 MiB) and sharding_coalesce_max_bytes (default 16 MiB). When reading multiple chunks from the same shard, nearby byte ranges are merged into a single request to the store if separated by no more than sharding_coalesce_max_gap_bytes and the merged read stays within sharding_coalesce_max_bytes. Defaults are seeded from the matching array.sharding_coalesce_max_gap_bytes / array.sharding_coalesce_max_bytes keys in [zarr.config][] at array-creation time, and can be overridden per array by passing config={...} to [zarr.create_array][]. (#3987)
Added Group.get_array, Group.get_group, AsyncGroup.get_array, and AsyncGroup.get_group: type-safe accessors that return the child array or group at a given path, raising ArrayNotFoundError / GroupNotFoundError if no node exists there, and ContainsGroupError / ContainsArrayError if the node is not of the requested kind. Unlike Group.__getitem__, which returns Array | Group, these methods have precise return types. Nested paths like "subgroup/subarray" are supported. (#4128)
ZipStore now accepts an open binary file-like object in place of a path, enabling
zip archives on remote storage (e.g. a file opened with fsspec or an
obstore.ReadableFile). Operations that require a filesystem location
(clear, move) raise NotImplementedError for file-object-backed stores. (#4187)
Stop emitting an UnstableSpecificationWarning when serializing the struct data type to Zarr V3 metadata. The struct data type now has a stable Zarr V3 specification. The legacy structured alias and the unspecified null_terminated_bytes, raw_bytes, and variable_length_bytes data types continue to warn. (#4100)
Fix equality comparison of ArrayV2Metadata and ArrayV3Metadata objects with a
NaN fill value. Such objects are now compared by their JSON-serialized form, so two
otherwise-identical metadata objects with a NaN (or infinite) fill value compare equal. (#2929)
Fixed BytesCodec.from_dict so that BytesCodec instances roundtrip to / from
their dict representation. BytesCodec.from_dict now interprets a missing
endian configuration as endian=None (matching what BytesCodec.to_dict
emits), instead of falling back to the system's native byte order. (#3417)
Fixed save_array, Group.__setitem__, and load for 0-dimensional arrays. (#3469)
Fixed inner-codec spec evolution for sharded arrays. The sharding codec now threads the array spec through its inner codec chain when evolving codecs, so a codec that changes the dtype upstream of BytesCodec no longer leaves the inner chain evolved against the wrong spec (which previously failed at decode time). This runs on the default BatchedCodecPipeline as well. Standard inner chains ([BytesCodec], [BytesCodec, ZstdCodec], transpose + bytes) are byte-identical to before. Restores the behavior of #2179. (#3885)
Make chunk normalization properly handle -1 as a compact representation of the
length of an entire axis. Reject several previously-accepted but ill-defined
chunk specifications: chunks=True (previously silently produced size-1 chunks),
chunk tuples shorter than the array's number of dimensions (previously padded to
the array's shape), and None as a per-dimension chunk size. These all now
raise informative errors. Also fix chunk handling for 0-length array dimensions,
and add explicit rejection of 0-length chunks. (#3899)
Handle missing consolidated metadata in leaf Group nodes. (#3954)
Corrected the JSON type definitions for the numpy.datetime64 and
numpy.timedelta64 data types in Zarr V3 metadata: the configuration object
(holding unit and scale_factor) is now required, matching the published
specifications for these data types. Also updated the specification links in
the docstrings to point to the zarr-extensions repository. (#3955)
Fixed writing to 0-dimensional arrays that use the sharding codec. Previously assigning to a 0-dimensional sharded array raised an error. (#3966)
Fix flaky stateful test bookkeeping when delete_dir matches string prefixes instead of true directory descendants. Previously a path such as 6/faNT… could be incorrectly removed when deleting 6/f. (See issue #3977.) (#3977)
FsspecStore.close() no longer closes the underlying fsspec filesystem or its
network session. fsspec caches and shares filesystem instances across callers,
so the store cannot know whether it is the only user, and closing a shared
session would break other stores; the filesystem's lifecycle belongs to
whoever created it. (#4165)
Fixed an invalid zarr.create_array example in the quick-start documentation (it passed an unsupported mode argument) and made the cloud-storage example execute against a mock S3 backend in CI. Added a test ensuring every Python code block in the documentation is either executed or explicitly opted out with a documented reason, so an invalid example can no longer go untested. (#4016)
Fixed ObjectStore.list_dir for object-store listings that include a directory-marker object matching the requested non-root prefix. (#4032)
Prevents mutation of the attributes dict provided by the user by copying them instead of keeping the reference (#4059)
Fixed several storage and codec bugs:
SuffixByteRequest larger than the value now correctly returns the whole value (matching HTTP bytes=-N suffix-range semantics), instead of silently returning incorrect data for MemoryStore.LoggingStore.get_partial_values and FsspecStore.get_partial_values no longer return empty results when key_ranges is passed as a one-shot iterable (e.g. a generator).Store.getsize_prefix no longer over-counts sibling keys that merely share a string prefix (e.g. getsize_prefix("foo") no longer includes keys under foobar/).ZipStore.close() no longer raises AttributeError when the store was created but never opened (including when used as a context manager without any I/O).codecs_from_list now raises a descriptive TypeError when a BytesBytesCodec immediately follows an ArrayArrayCodec, instead of a misleading "Required ArrayBytesCodec was not found" ValueError.(#4074)
Fixed writing Fortran-ordered (F-contiguous) arrays through the variable-length string and bytes codecs and through numcodecs array-array filters such as Delta, FixedScaleOffset and PackBits. Chunks are now passed to numcodecs as C-contiguous arrays, so elements are no longer stored in transposed order. (#4116)
Fix silent byte-order corruption for structured dtypes with the bytes codec: multi-byte fields are now byte-swapped to the codec's configured endian on write and decoded honoring it on read, so non-native-endian structured data (e.g. big-endian fields, as produced by virtual references to external data) round-trips correctly. (#4141)
Fix zarr.api.asynchronous.open_like so it can create a new array by default when the
target path does not already exist. It now defaults to mode="a"; when using a read-only
store to open an existing array, pass mode="r" explicitly. (#3352)
MemoryStore now copies buffers as they are written, so it never retains the
caller's memory. Previously an uncompressed write handed the store a zero-copy
view of the user's array, and mutating that array afterwards would silently
rewrite chunks already committed to the store.
Only MemoryStore is affected: stores that serialize on write, such as
LocalStore and ZipStore, never aliased the caller's memory. Uncompressed
writes to a MemoryStore are correspondingly slower, since the copy that makes
the stored data independent is now actually performed; compressed writes are
unchanged. Buffers supplied through the store_dict argument remain the
caller's responsibility and are stored as-is. (#4157)
Fixed the opt-in FusedCodecPipeline for sharded arrays whose inner or index codec chain contains a codec implementing only the async codec interface (no SupportsSyncCodec). Such arrays previously raised TypeError: All codecs must implement SupportsSyncCodec on both read and write; the pipeline now declines its synchronous fast path for them and falls back to the async path, matching the behavior of the default BatchedCodecPipeline. Fully sync-capable codec chains keep the fast path unchanged. (#4179)
Fixed TypeError: unhashable type: 'writeable void-scalar' when writing to sharded arrays whose fill value is a np.void scalar, e.g. arrays with a structured dtype.
ArraySpec equality and hashing now compare the fill value by its byte representation rather than numeric equality. As a result, two specs with a NaN (or NaT) fill value now compare equal, while fill values of -0.0 and 0.0 now compare unequal. This also restores the sharding codec's per-chunk spec cache, which had been disabled because of this bug. (#4183)
FusedCodecPipeline no longer runs chunk IO and codec compute on the thread
driving zarr's internal event loop. Previously each read/write executed its
synchronous fast path inline on that loop thread, and because every sync-API
call from every user thread is serviced by the same loop, concurrent
operations serialized behind each other's codec work — reported as the fused
pipeline being slower than BatchedCodecPipeline for zstd-compressed data
under multi-threaded (e.g. dask) access. The synchronous batch now runs on a
worker thread (one hop per batch, not per chunk), keeping the loop free.
Multi-threaded single-chunk reads of compressed data now scale with reader
threads; single-threaded performance is unchanged. (#4194)
The end-to-end benchmarks no longer invoke sudo to drop the OS page cache during a regular pytest run. Cache clearing is now opt-in via the ZARR_BENCHMARK_CLEAR_CACHE environment variable, which the benchmark CI jobs set. (#4199)
Fixed the opt-in FusedCodecPipeline for serializers that advertise the partial-decode/encode mixins with only the documented async partial methods: the partial dispatch previously asserted on the private _decode_partial_sync/_encode_partial_sync hooks (an AssertionError, or an AttributeError mid-IO under python -O); such codecs now take the full-chunk sync path. (#4201)
Fixed FusedCodecPipeline (the opt-in synchronous pipeline) silently skipping
array-array/bytes-bytes codecs placed outside a sharding serializer on its
partial-decode/partial-encode fast paths. With an outer compressor (e.g.
compressors=[GzipCodec()] around a ShardingCodec serializer), the fused
pipeline wrote non-conforming stored bytes that BatchedCodecPipeline (and any
other conforming reader) could not read, and could fail to read data that
BatchedCodecPipeline had written. With an outer array-array codec (e.g.
TransposeCodec), it silently returned wrong data in both directions with no
error. Only the opt-in FusedCodecPipeline was affected; the default
BatchedCodecPipeline was never impacted. (#4202)
Fixed silent data corruption in the experimental FusedCodecPipeline: reordering or duplicating fancy-index reads (e.g. arr[perm, :], arr.oindex[[0, 0, 1], :]) on uncompressed, crc-free sharded arrays could return the shard in natural order because the vectorized whole-shard decode accepted any selection whose output shape matched the shard shape. The bulk decode now fires only for identity full-shard reads, declines structured dtypes (whose byte-order handling it lacks), and requires shard-index offsets to exactly tile the data section, so corrupt indexes with overlapping or out-of-range offsets can no longer be served as array data. (#4203)
ManagedMemoryStore.get_sync/set_sync/delete_sync now apply the store's
path prefix, matching the async get/set/delete methods. Previously the
sync methods were inherited unchanged from MemoryStore and used the raw key,
so code that takes the sync fast path (e.g. FusedCodecPipeline) would read
and write chunks outside the store's path prefix, silently returning fill
values when the data was re-read through a fresh handle. GpuMemoryStore.set_sync
now converts its value to a gpu.Buffer, matching set, so writes through the
sync API keep the store's all-values-are-GPU invariant. Also fixed
ManagedMemoryStore.get_partial_values applying its path prefix twice
whenever path is non-empty, which made it always return None for every
requested key.
The shared store test suite (zarr.testing.store.StoreTests) gained
sync/async parity checks — comparing sync and async observations of the same
key on the same store instance, including with a byte_range — so every
store subclass now exercises this invariant. The suite's former
test_get_bytes/test_get_json methods (and their _sync variants) were
folded into these parity tests and no longer exist as separate methods. (#4204)
Fixed several small correctness issues from the codec-pipeline performance work: construction-time
codec warnings (e.g. sharding's "disables partial reads" warning) no longer fire twice per array
open — including for FusedCodecPipeline, which previously re-warned via its own codec-chain
reconstruction and, on the async fallback path, on every decode/encode call; concurrent_iter now
schedules its tasks eagerly, matching its documented contract; an invalid
codec_pipeline.max_workers config/environment value now warns and falls back to the default
instead of raising mid-read; and FusedCodecPipeline's async fallback helpers now cancel
already-spawned fetch/decode/write tasks instead of abandoning them in the background when one
fails. (#4205)
Fixed FusedCodecPipeline's gating of its synchronous fast paths: stores exposing only part of the sync surface (e.g. set_sync without get_sync) now fall back cleanly to the async path instead of failing mid-write, and WrapperStore now forwards get_sync/set_sync/delete_sync to the wrapped store so wrapped sync-capable stores keep the fast path. The capability decision uses a private, interim convention (zarr.abc.store._store_supports_sync_io) rather than new public API, pending a formal sync/async store architecture. Also fixed LatencyStore: synchronous reads and writes now pay the configured latency, get_ranges/get_partial_values no longer bypass latency injection, and derived stores (e.g. from with_read_only) keep a stochastic (loc, scale) latency configuration instead of freezing a single sample. (#4206)
DefaultChunkKeyEncoding.decode_chunk_key now validates that a chunk key
starts with the configured c<separator> prefix and raises ValueError for
malformed keys, instead of silently decoding them incorrectly. (#4219)
Document the changes to zarr.errors in the 3.0 migration guide, including the removal of v2 exception classes and the introduction of NodeNotFoundError. (#3009)
Clarify the difference between zarr.load and zarr.open in their docstrings.
load eagerly reads data into an in-memory array, while open returns a
lazy Array or Group backed by the store, with See Also cross-references
linking the two. (31817c68)
Updated the custom dtype example in examples/custom_dtype/custom_dtype.py to
use only the public API, eliminating all non-public imports, illustrating what
users should do.
To better support this, the following types and functions were made available from public modules:
| Type/Function | Non-public module | Public module |
|---|---|---|
DataTypeValidationError |
zarr.core.dtype.common |
zarr.errors |
JSON |
zarr.core.common |
zarr.types |
ZarrFormat |
zarr.core.common |
zarr.types |
DTypeConfig_V2 |
zarr.core.dtype.common |
zarr.types |
DTypeJSON |
zarr.core.dtype.common |
zarr.types |
DTypeSpec_V2 |
zarr.core.dtype.common |
zarr.dtype |
check_dtype_spec_v2 |
zarr.core.dtype.common |
zarr.dtype |
DataTypeValidationError was moved to zarr.errors. Importing it from
zarr.core.dtype.common (its original location), zarr.core.dtype, or
zarr.dtype still works but now raises a ZarrDeprecationWarning. The remaining
types and functions are simply re-exported from the listed public module. (#4052)
Document a self-merge policy in the contributor guide, describing when a core developer may merge their own pull request without a second reviewer and which changes warrant more caution. (#4053)
Fixed many documentation errors found in a full review of the user guide, including
prose contradicted by rendered example output on the performance page, invisible
code blocks, an incorrect S3 example, stale "not yet implemented" claims in the
v3 migration guide, and undocumented optional dependency groups. Also improved
navigation order, cross-linking between pages, and coverage of group member
enumeration, bulk attribute updates, and the use_consolidated keyword. (#4132)
Fixed the documented default of max_age_seconds in the CacheStore docstring: the default is "infinity" (no expiration), not None, which is rejected. Also noted that cache_store must support deletes. (#4133)
Added a blog section to the documentation, with a post covering two performance
highlights of the 3.3.0 release: the opt-in FusedCodecPipeline and byte-range
coalescing for partial reads of sharded arrays.
Added two runnable examples that accompany the post:
examples/codec_pipeline_performance compares the BatchedCodecPipeline and
FusedCodecPipeline on a sharded array across two stores and two codec
regimes, showing when the fused pipeline's thread pool helps and when it does
not, and examples/sharding_coalescing demonstrates how read coalescing
reduces the number of store requests when reading subregions of a sharded
array.
Also removed the hardware-specific speedup figures from the FusedCodecPipeline
release note, since they depend on the array layout, codec, and machine. (#4191)
The BloscShuffle and BloscCname enums (zarr.codecs.BloscShuffle,
zarr.codecs.BloscCname) are now deprecated. Pass the equivalent literal
string (e.g. "zstd", "bitshuffle") when constructing a BloscCodec.
The enum classes remain importable but emit DeprecationWarning on member
access, and will be removed in a future release. They are no longer Enum
subclasses: constructor calls (e.g. BloscCname("zstd")), iteration, and
.value access no longer work. BloscCodec.cname and
BloscCodec.shuffle are now plain strings rather than enum members.
Additional renames in zarr.codecs.blosc from the same change: the type
aliases Shuffle and CName are now BloscShuffleLiteral and
BloscCnameLiteral, the constant SHUFFLE is now BLOSC_SHUFFLE
(with a new BLOSC_CNAME alongside it), and BloscShuffle.from_int
now returns a literal string rather than an enum member. (#3963)
The Endian (zarr.codecs.bytes.Endian) and ShardingCodecIndexLocation
(zarr.codecs.ShardingCodecIndexLocation) enums are now deprecated. Pass the
equivalent literal string instead (e.g. "little" / "big", "start" /
"end"). The enum classes remain importable but emit DeprecationWarning
on member access, and will be removed in a future release. BytesCodec.endian
and ShardingCodec.index_location are now plain strings rather than enum
members.
Two follow-on changes from this deprecation:
NDBuffer.byteorder now returns a literal string ("little" or
"big") rather than an Endian member. Subclasses overriding this
property should update their return type.zarr.codecs.bytes.default_system_endian was
removed. BytesCodec() continues to default to sys.byteorder;
external callers that imported default_system_endian should use
sys.byteorder directly.Additionally, the module-level function zarr.codecs.sharding.parse_index_location
was made private as part of this change.
(#3968)
Removed the NumPy 1.x implementation of the VariableLengthUTF8 data type because NumPy 1.x is no longer supported under SPEC0. (#3973)
feat:metadata package by @d-v-b in #3919
Full Changelog: v3.2.0...v3.2.1
CastValue validation bug where the "can we use an out-of-range mode" check
inspected the source dtype instead of the target dtype. This meant arrays with a
float source dtype and an integer target dtype incorrectly raised a ValueError
when configured with a wrap out-of-range mode. (#3938)CastValue to convert a single-byte source dtype
(int8) to a multi-byte target dtype (int16) raised a ValueError from
BytesCodec about a missing endian configuration. (#3941)ManagedMemoryStore instead of fsspec's memory-backed store. After this change, store URLs with a "memory" scheme are handled differently when fsspec is installed:
with fsspec, a FsspecStore backed by a MemoryFileSystem is used. Without fsspec,
a ManagedMemoryStore is used. (#3944)chore: remove deprecated convenience and creation modules by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/3900
DimensionNames type to DimensionNamesLike. by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/3800CodecPipeline.read() by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/3828CodecPipeline.write by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/3836coverage run instead of pytest --cov by @maxrjones in https://github.com/zarr-developers/zarr-python/pull/3847zarr_version parameter by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/3901structured and struct zarr-extension defined dtypes by @BrianMichell in https://github.com/zarr-developers/zarr-python/pull/3781Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.1.6...v3.2.0
Adds a new in-memory storage backend called ManagedMemoryStore. Instances of ManagedMemoryStore
function similarly to MemoryStore, but instances of ManagedMemoryStore can be constructed from
a URL like memory://store. (#3679)
Added array.read_missing_chunks configuration option. When set to False, reading missing chunks raises a ChunkNotFoundError instead of filling them with the array's fill value. (#3748)
Added Struct class (subclass of Structured) implementing the zarr-extensions struct dtype spec. Uses object-style field format and dict fill values. Legacy Structured remains available for backward compatibility. (#3781)
Add support for rectilinear (variable-sized) chunk grids. This feature is experimental and
must be explicitly enabled via zarr.config.set({'array.rectilinear_chunks': True}).
Rectilinear chunks can be used through:
[[10, 20, 30], [50, 50]]) to chunks
in zarr.create_array, zarr.from_array, zarr.zeros, zarr.ones, zarr.full,
zarr.open, and related functions, or to chunk_shape in zarr.create.rectilinear chunk grid are read
transparently via zarr.open and zarr.open_array.Breaking change: The validate method on BaseCodec and CodecPipeline now receives
a ChunkGridMetadata instance instead of a ChunkGrid instance for the chunk_grid
parameter. Third-party codecs that override validate and inspect the chunk grid will need to
update their type annotations. No known downstream packages were using this parameter. (#3802)
Add cast_value and scale_offset codecs. (#3874)
SyncError raised when assigning a zarr.Array as the value in a __setitem__ call (e.g. dst[:] = src where src is a zarr array). The source array is now converted to a NumPy array before entering the async codec pipeline. (#3611)uint32 dtypes resulting e.g.
from bit wise operations on uint32 arrays on Windows. (#3797)ZipStore.list(), list_dir(), and exists() to auto-open the zip file when called before open(), consistent with the existing behavior of get() and set(). (#3846)NaT default fill values for datetime64 and timedelta64 data types. Equality checks now use numpy.isnat so that the default fill value compares correctly against NaT. (#3863)Datetime64 data type when creating the default Nat scalar value. (#3920)zarr.storage.init_group in v3 migration guide, with replacement using zarr.open_group/zarr.create_group. (#2720)threading.max_workers configuration option in the performance guide. (#3492)batch_info parameter in the CodecPipeline.write
method docstring. (#3836)zarr.convenience and zarr.creation modules. (#3900)zarr_version parameter from several functions and methods. That parameter is replaced with zarr_format. (#3901)Group methods array, require_dataset, and create_dataset. (#3902)AsyncArray.create and Array.create methods. (#3903)chore: remove deprecated convenience and creation modules by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/3900
DimensionNames type to DimensionNamesLike. by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/3800CodecPipeline.read() by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/3828CodecPipeline.write by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/3836coverage run instead of pytest --cov by @maxrjones in https://github.com/zarr-developers/zarr-python/pull/3847zarr_version parameter by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/3901structured and struct zarr-extension defined dtypes by @BrianMichell in https://github.com/zarr-developers/zarr-python/pull/3781Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.1.6...v3.2.0rc1
Fix deprecation of setting shape on a numpy array in 2.5+ by @mscheltienne in https://github.com/zarr-developers/zarr-python/pull/3648
See release notes at https://zarr.readthedocs.io/en/stable/release-notes.html
array.target_shard_size_bytes by @ilan-gold in https://github.com/zarr-developers/zarr-python/pull/3599_iter_shard methods / functions by @melonora in https://github.com/zarr-developers/zarr-python/pull/3615rich as required for tree() by @ianhi in https://github.com/zarr-developers/zarr-python/pull/3778Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.1.5...v3.1.6
config on the Array and
AsyncArray classes. The previous AsyncArray._config attribute is now a deprecated alias for AsyncArray.config. (#3668)Array / AsyncArray instance with a new runtime configuration, and fixes inaccurate documentation about the write_empty_chunks configuration parameter. (#3668)_morton_order with hybrid ceiling+argsort strategy. (#3718)_transform_list_dir implementation to correctly relativize paths (removing lstrip usage). (#3657)numpy.dtypes.StringDType with na_object set. (#3695)CacheStore, LoggingStore and LatencyStore now support with_read_only. (#3700)CacheStore. (#3710)BaseFloat._check_scalar rejects invalid string values. (#3586)copy=False in reshape operation. (#3649)3.1.4, not pi by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/3594
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.1.4...v3.1.5
See release notes at https://zarr.readthedocs.io/en/stable/release-notes.html
See release notes at https://zarr.readthedocs.io/en/stable/release-notes.html
None by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/3535auto sharding via zarr.config by @ilan-gold in https://github.com/zarr-developers/zarr-python/pull/3574async_array public by @ilan-gold in https://github.com/zarr-developers/zarr-python/pull/3556Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.1.3...v3.1.4
Array class can now also be parametrized in the same manner as the AsyncArray class, allowing Zarr format v2 and v3 Arrays to be distinguished.
New types have been added to zarr.types to help with this. (#3304)zarr.experimental.cache_store.CacheStore, a Store that implements caching by combining two other Store instances. See the docs page for more information about this feature. (#3366)zarr.experimental module for unstable user-facing features. (#3490)array.target_shard_size_bytes to [zarr.config][] to allow users to set a maximum number of bytes per-shard when shards="auto" in, for example, [zarr.create_array][]. (#3547)async_array on the [zarr.Array][] class public (_async_array will remain untouched, but its stability is not guaranteed). (#3556)PCodec from being properly resolved when loading arrays using that compressor. (#3483)"must_understand" key set to "false"). (#3530)"consolidated_metadata" key was written to metadata documents even when
consolidated metadata was not used, resulting in invalid metadata documents. (#3535)examples directory to give each example its own sub-directory. Adds content to the docs for each example. (#3502)Use atomic writes for new files in LocalStore by @shoyer in https://github.com/zarr-developers/zarr-python/pull/3412
ChunkCoords definition by @LDeakin in https://github.com/zarr-developers/zarr-python/pull/3425Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.1.2...v3.1.3
ChunkKeyEncoding, which can be registered via register_chunk_key_encoding or as an entry point under zarr.chunk_key_encoding. (#3436)ones_like, full_like, empty_like, zeros_like and open_like functions from accepting an explicit specification of array attributes like shape, dtype, chunks etc. The functions full_like, empty_like, and open_like now also more consistently infer a fill_value parameter from the provided array. (#2992)zarr.create_array with the data parameter set to a NumPy array. Previously Zarr was iterating over the newly created array with a granularity that was too low. Now Zarr chooses a granularity that matches the size of the stored objects for that array. (#3422)root['/subgroup'] works equivalently to root['subgroup'] when using consolidated metadata. (#3428)zarr.group no longer errors. This fixes a regression introduced in version 3.1.2. (#3431)fill_value to a float like 0.0 when the data type of the array is an integer is a common mistake. This change lets Zarr Python read arrays with this erroneous metadata, although Zarr Python will not create such arrays. (#3448)Store.set_partial_writes method, which was not used by Zarr-Python, has been removed. store.supports_partial_writes is now always False. (#2859)Remove outdated v3 release announcement bullet from release notes by @nikkhilaaryan in https://github.com/zarr-developers/zarr-python/pull/3235
in and or instead of multipleif's by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/3266parse_dtype by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/3264create_array api on on Group. by @lhao03 in https://github.com/zarr-developers/zarr-python/pull/3375project.urls by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/3386KeyError for unknown codecs with a more specific error class by @keewis in https://github.com/zarr-developers/zarr-python/pull/3395Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.1.0...v3.1.2
create_array caused by iterating over chunk-aligned regions instead of shard-aligned regions when writing data. Additionally, the behavior of nchunks_initialized has been adjusted. This function consistently reports the number of chunks present in stored objects, even when the array uses the sharding codec. (#3299)mode="r+" will no longer create new arrays or groups. (#3307)zarr.errors.ArrayNotFoundError, which is raised when attempting to open a zarr array that does not exist, and zarr.errors.NodeNotFoundError, which is raised when failing to open an array or a group in a context where either an array or a group was expected. (#3367)config is handled properly when opening an existing array. (#3378)See release notes https://zarr.readthedocs.io/en/stable/release-notes.html
See release notes https://zarr.readthedocs.io/en/stable/release-notes.html
in and or instead of multipleif's by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/3266parse_dtype by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/3264Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.1.0...v3.1.1
.getsize() and .getsize_prefix() for ObjectStore. (#3227)order keyword argument no longer raises a warning. (#3112)config and write_empty_chunks arguments to reflect the current behaviour (write_empty_chunks takes precedence). (#3112)order argument now consistently ignores this argument and raises a warning. (#3112)from_array][zarr.api.asynchronous.from_array] to copy a Zarr format 2 array to a Zarr format 3 array, if the memory order of the input array is "F" a warning is raised and the order ignored. This is because Zarr format 3 arrays are always stored in "C" order. (#3112)config argument to [zarr.create][zarr.create] (and functions that create arrays) is now used - previously it had no effect. (#3112)ZDType][zarr.core.dtype.ZDType] raise a NotImplementedError when invoked. (#3251)parse_data_type to include strings and Sequences.zarr.core.dtype.parse_data_type to a new function called zarr.dtype.parse_dtype. This change ensures that nomenclature is consistent across the codebase. zarr.core.dtype.parse_data_type remains, so this change is not breaking. (#3264)inf, -inf, and nan values from being stored in attributes. (#3280)Group.nmembers()][zarr.Group.nmembers] ignoring depth when using consolidated metadata. (#3287)parse_data_type function. Expand the docstring for the parse_data_type function. (#3249)remove usage of the _deprecate_positional_args decorator, and tests for its behavior by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/…
See release notes in the Zarr documentation
info_complete by @jsignell in https://github.com/zarr-developers/zarr-python/pull/3190create_array signatures consistent by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/2819create() by @dstansby in https://github.com/zarr-developers/zarr-python/pull/3111from_array_metadata_and_store to CodecPipeline by @LDeakin in https://github.com/zarr-developers/zarr-python/pull/3233Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.10...v3.1.0
Ensure that invocations of create_array use consistent keyword arguments, with consistent defaults.
[zarr.api.synchronous.create_array][] now takes a write_data keyword argument
The Group.create_array method takes data and write_data keyword arguments.
The functions [zarr.api.asynchronous.create][], [zarr.api.asynchronous.create_array]
and the methods Group.create_array, Group.array, had the default
fill_value changed from 0 to the DEFAULT_FILL_VALUE value, which instructs Zarr to
use the default scalar value associated with the array's data type as the fill value. These are
all functions or methods for array creation that mirror, wrap or are wrapped by, another function
that already has a default fill_value set to DEFAULT_FILL_VALUE. This change is necessary
to make these functions consistent across the entire codebase, but as this changes default values,
new data might have a different fill value than expected after this change.
For data types where 0 is meaningful, like integers or floats, the default scalar is 0, so this
change should not be noticeable. For data types where 0 is ambiguous, like fixed-length unicode
strings, the default fill value might be different after this change. Users who were relying on how
Zarr interpreted 0 as a non-numeric scalar value should set their desired fill value explicitly
after this change.
Added public API for Buffer ABCs and implementations.
Use zarr.buffer to access buffer implementations, and
zarr.abc.buffer for the interface to implement new buffer types.
Users previously importing buffer from zarr.core.buffer should update their
imports to use zarr.buffer. As a reminder, all of zarr.core is
considered a private API that's not covered by zarr-python's versioning policy. (#2871)
Adds zarr-specific data type classes.
This change adds a ZDType base class for Zarr V2 and Zarr V3 data types. Child classes are
defined for each NumPy data type. Each child class defines routines for JSON serialization.
New data types can be created and registered dynamically.
Prior to this change, Zarr Python had two streams for handling data types. For Zarr V2 arrays, we used NumPy data type identifiers. For Zarr V3 arrays, we used a fixed set of string enums. Both of these systems proved hard to extend.
This change is largely internal, but it does change the type of the dtype and data_type
fields on the ArrayV2Metadata and ArrayV3Metadata classes. Previously, ArrayV2Metadata.dtype
was a NumPy dtype object, and ArrayV3Metadata.data_type was an internally-defined enum.
After this change, both ArrayV2Metadata.dtype and ArrayV3Metadata.data_type are instances of
ZDType. A NumPy data type can be generated from a ZDType via the ZDType.to_native_dtype()
method. The internally-defined Zarr V3 enum class is gone entirely, but the ZDType.to_json(zarr_format=3)
method can be used to generate either a string, or dictionary that has a string name field, that
represents the string value previously associated with that enum.
For more on this new feature, see the documentation (#2874)
Added NDBuffer.empty method for faster ndbuffer initialization. (#3191)
The minimum version of NumPy has increased to 1.26. (#3226)
Add an alternate from_array_metadata_and_store constructor to CodecPipeline. (#3233)
Fixes a variety of issues related to string data types.
VariableLengthUTF8 data type Zarr V3 identifier in alignment with Zarr Python 3.0.8VariableLengthUTF8 data type that checks against version 3.0.8VariableLengthUTF8 data type with str, "str", or "string". (#3170)Add human readable size for No. bytes stored to info_complete (#3190)
Restores the ability to create a Zarr V2 array with a null fill value by introducing a new
class DefaultFillValue, and setting the default value of the fill_value parameter in array
creation routines to an instance of DefaultFillValue. For Zarr V3 arrays, None will act as an
alias for a DefaultFillValue instance, thus preserving compatibility with existing code. (#3198)
Fix the type of ArrayV2Metadata.codec to constrain it to numcodecs.abc.Codec | None.
Previously the type was more permissive, allowing objects that can be parsed into Codecs (e.g., the codec name).
The constructor of ArrayV2Metadata still allows the permissive input when creating new objects. (#3232)
Add a self-contained example of data type extension to the examples directory, and expanded
the documentation for data types. (#3157)
Add a description on how to create a RemoteStore of a specific filesystem to the Remote Store section in docs/user-guide/storage.md.
State in the docstring of FsspecStore.from_url that the filesystem type is inferred from the URL scheme.
It should help a user handling the case when the type of FsspecStore doesn't match the URL scheme. (#3212)
Removes default chunk encoding settings (filters, serializer, compressors) from the global configuration object.
This removal is justified on the basis that storing chunk encoding settings in the config required a brittle, confusing, and inaccurate categorization of array data types, which was particularly unsuitable after the recent addition of new data types that didn't fit naturally into the pre-existing categories.
The default chunk encoding is the same (Zstandard compression, and the required object codecs for variable length data types), but the chunk encoding is now generated by functions that cannot be reconfigured at runtime. Users who relied on setting the default chunk encoding via the global configuration object should instead specify the desired chunk encoding explicitly when creating an array.
This change also adds an extra validation step to the creation of Zarr V2 arrays, which ensures that
arrays with a VariableLengthUTF8 or VariableLengthBytes data type cannot be created without the
correct "object codec". (#3228)
Removes support for passing keyword-only arguments positionally to the following functions and methods:
save_array, open, group, open_group, create, get_basic_selection, set_basic_selection,
get_orthogonal_selection, set_orthogonal_selection, get_mask_selection, set_mask_selection,
get_coordinate_selection, set_coordinate_selection, get_block_selection, set_block_selection,
Group.create_array, Group.empty, Group.zeroes, Group.ones, Group.empty_like, Group.full,
Group.zeros_like, Group.ones_like, Group.full_like, Group.array. Prior to this change,
passing a keyword-only argument positionally to one of these functions or methods would raise a
deprecation warning. That warning is now gone. Passing keyword-only arguments to these functions
and methods positionally is now an error.
Remove breaking check about auto_mkdir for FSSpecStore by @maxrjones in https://github.com/zarr-developers/zarr-python/pull/3193
_make_async in _fsspec.py by @tasansal in https://github.com/zarr-developers/zarr-python/pull/3195Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.9...v3.0.10
(chore): release notes cleanup by @ilan-gold in https://github.com/zarr-developers/zarr-python/pull/3074
np.zeros for buffer creation with fill_value=0 by @ilan-gold in https://github.com/zarr-developers/zarr-python/pull/3082TCH → TC by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/3032zarr.save for given path and multiple args arrays by @brokkoli71 in https://github.com/zarr-developers/zarr-python/pull/3127zarr.open default for argument mode when store is read_only by @brokkoli71 in https://github.com/zarr-developers/zarr-python/pull/3128Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.8...v3.0.9
Add zarr.storage.FsspecStore.from_mapper() so that zarr.open() supports stores of type fsspec.mapping.FSMap. (#2774)
Implemented move for LocalStore and ZipStore. This allows users to move the store to a different root path. (#3021)
Added zarr.errors.GroupNotFoundError, which is raised when attempting to open a group that does not exist. (#3066)
Adds fill_value to the list of attributes displayed in the output of the AsyncArray.info() method. (#3081)
Use numpy.zeros instead of np.full for a performance speedup when creating a zarr.core.buffer.NDBuffer with fill_value=0. (#3082)
Adds a with_read_only convenience method to the Store abstract base class (raises NotImplementedError) and implementations to the MemoryStore, ObjectStore, LocalStore, and FsspecStore classes. (#3138)
Ignore stale child metadata when reconsolidating metadata. (#2921)
For Zarr format 2, allow fixed-length string arrays to be created without automatically inserting a
Vlen-UT8 codec in the array of filters. Fixed-length string arrays do not need this codec. This
change fixes a regression where fixed-length string arrays created with Zarr Python 3 could not be read with Zarr Python 2.18. (#3100)
When creating arrays without explicitly specifying a chunk size using zarr.create and other
array creation routines, the chunk size will now set automatically instead of defaulting to the data shape.
For large arrays this will result in smaller default chunk sizes.
To retain previous behaviour, explicitly set the chunk shape to the data shape.
This fix matches the existing chunking behaviour of
zarr.save_array and zarr.api.asynchronous.AsyncArray.create. (#3103)
When zarr.save has an argument path=some/path/ and multiple arrays in args, the path resulted in some/path/some/path due to using the path
argument twice while building the array path. This is now fixed. (#3127)
Fix zarr.open default for argument mode when store is read_only (#3128)
Suppress FileNotFoundError when deleting non-existent keys in the obstore adapter.
When writing empty chunks (i.e. chunks where all values are equal to the array's fill value) to a zarr array, zarr
will delete those chunks from the underlying store. For zarr arrays backed by the obstore adapter, this will potentially
raise a FileNotFoundError if the chunk doesn't already exist.
Since whether or not a delete of a non-existing object raises an error depends on the behavior of the underlying store,
suppressing the error in all cases results in consistent behavior across stores, and is also what zarr seems to expect
from the store. (#3140)
Trying to open a StorePath/Array with mode='r' when the store is not read-only creates a read-only copy of the store. (#3156)
More consistent store docstrings by @dstansby in https://github.com/zarr-developers/zarr-python/pull/2976
print statement from structured dtype metadata parsing by @tasansal in https://github.com/zarr-developers/zarr-python/pull/3007typesize on Blosc codec by @ilan-gold in https://github.com/zarr-developers/zarr-python/pull/2962AsyncArray, Array by @brokkoli71 in https://github.com/zarr-developers/zarr-python/pull/3049print_debug_info function by @ianhi in https://github.com/zarr-developers/zarr-python/pull/2913Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.7...v3.0.8
!!! warning
In versions 3.0.0 to 3.0.7 opening arrays or groups with `mode='a'` (the default for many builtin functions) would cause any existing paths in the store to be deleted. This is fixed in 3.0.8, and we recommend all users upgrade to avoid this bug that could cause unintentional data loss.
print_debug_info function for bug reports. (#2913)Fix a bug that prevented the number of initialized chunks being counted properly. (#2862)
Fixed sharding with GPU buffers. (#2978)
Fix structured dtype fill value serialization for consolidated metadata (#2998)
It is now possible to specify no compressor when creating a zarr format 2 array.
This can be done by passing compressor=None to the various array creation routines.
The default behaviour of automatically choosing a suitable default compressor remains if the compressor argument is not given.
To reproduce the behaviour in previous zarr-python versions when compressor=None was passed, pass compressor='auto' instead. (#3039)
Fixed the typing of dimension_names arguments throughout so that it now accepts iterables that contain None alongside str. (#3045)
Using various functions to open data with mode='a' no longer deletes existing data in the store. (#3062)
Internally use typesize constructor parameter for numcodecs.blosc.Blosc to improve compression ratios back to the v2-package levels. (#2962)
Specifying the memory order of Zarr format 2 arrays using the order keyword argument has been fixed. (#2950)
Modify the link in README.md from V2 to V3 docs by @arkdong in https://github.com/zarr-developers/zarr-python/pull/2915
obstore-based Store implementation by @kylebarron in https://github.com/zarr-developers/zarr-python/pull/1661zarr.array from from an existing zarr.Array by @brokkoli71 in https://github.com/zarr-developers/zarr-python/pull/2622Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.6...v3.0.7
zarr.from_array using concurrent streaming of source data (#2622)__getitem__ changed
to NDArrayLikeOrScalar. This change is to make the behavior of 0-dimensional arrays consistent with
numpy scalars. (#2718)fill_value serialization for NaN in ArrayV2Metadata and add property-based testing of round-trip serialization (#2802)ConsolidatedMetadata serialization of nan, inf, and -inf to be
consistent with the behavior of ArrayMetadata. (#2996)fix: restore attrs del functionality by @ianhi in https://github.com/zarr-developers/zarr-python/pull/2908
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.5...v3.0.6
del z.attrs['key'] to actually delete the key. (#2908)Avoid creating persistent files during tests by @moradology in https://github.com/zarr-developers/zarr-python/pull/2860
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.4...v3.0.5
StorePath creation would not apply standard path normalization to the path parameter,
which led to the creation of arrays and groups with invalid keys. (#2850)Unnecessary lambda expression by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/2828
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.3...v3.0.4
ArrayV2Metadata could save filters as an empty array. (#2847)See release notes https://zarr.readthedocs.io/en/stable/release-notes.html#release-3-0-3
See release notes https://zarr.readthedocs.io/en/stable/release-notes.html#release-3-0-3
needs release notes by @moradology in https://github.com/zarr-developers/zarr-python/pull/2781Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.2...v3.0.3
zarr.config.enable_gpu to update Zarr's configuration to use GPUs. (#2751)LocalStore learned to delete_dir. This makes array and group deletes more efficient. (#2804)zarr.testing.strategies.array_metadata to generate ArrayV2Metadata and ArrayV3Metadata instances. (#2813)shards to Hypothesis strategy for generating arrays. (#2822)zarr.empty and an empty zarr.core.buffer.cpu.NDBuffer will now be filled with the
specified fill value, or with zeros if no fill value is provided.
This fixes a bug where Zarr format 2 data with no fill value was written with un-predictable chunk sizes. (#2755)FsspecStore.list (#2778)needs release notes with labeler action (#2781)create_array to ensure that any groups implied by the array's name are created if they do not already exist. Also simplifies the type signature for any function that takes an ArrayConfig-like object. (#2795)doc: seed unreleased release notes by @jhamman in https://github.com/zarr-developers/zarr-python/pull/2728
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.1...v3.0.2
getsize() and getsize_prefix() in StoreTests. (#2693)ValueError is raised for invalid byte range syntax in StoreTests. (#2693)StoreTests. (#2693)StoreTests. (#2693)LoggingStore.open(). (#2693)LoggingStore is now a generic class. (#2693)test_store_repr, test_store_supports_writes,
test_store_supports_partial_writes, and test_store_supports_listing
to be implemented using @abstractmethod, rather than raising NotImplementedError. (#2693)StoreTests. (#2693)StoreTests. (#2693)init_array for initializing an array in storage, and refactors create_array
to use init_array. create_array takes two new parameters: data, an optional array-like object, and write_data, a bool which defaults to True.
If data is given to create_array, then the dtype and shape attributes of data are used to define the
corresponding attributes of the resulting Zarr array. Additionally, if data is given and write_data is True,
then the values in data will be written to the newly created array. (#2761)AsyncFileSystemWrapper. (#2533)LoggingStore and WrapperStore such that 'other' must also be a LoggingStore or WrapperStore respectively, rather than only checking the types of the stores they wrap. (#2693)ZipStore is open before getting or setting any values. (#2693)LoggingStore. (#2693)StoreTests. (#2693)ZipStore to make sure the correct attributes are saved when instances are pickled.
This fixes a previous bug that prevented using ZipStore with a ProcessPoolExecutor. (#2762)botocore and fsspec. (#2768)botocore is not installed.
Previously they would have failed with an import error. (#2768)changes directory in the zarr-python repository, instead of directly to the changelog file. (#2736)ChunkKeyEncodingLike to model the union of ChunkKeyEncoding instances and the dict form of the
parameters of those instances. ChunkKeyEncodingLike should be used by high-level functions to provide a convenient
way for creating ChunkKeyEncoding objects. (#2763)doc: add release announcement banner by @jhamman in https://github.com/zarr-developers/zarr-python/pull/2677
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.0...v3.0.1
zarr.from_array using concurrent streaming (#2622).order argument for Zarr format 2 arrays (#2679).zarr-python version 2 (#2694).Deprecate the experimental v3 implementation by @jhamman in https://github.com/zarr-developers/zarr-python/pull/1802
Read the blog post about the 3.0 release: https://zarr.dev/blog/zarr-python-3-release/
CODE_OF_CONDCUT.md file from the Zarr-Python repo by @MSanKeys963 in https://github.com/zarr-developers/zarr-python/pull/1572hatch for packaging by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/1592v3 branch by @DahnJ in https://github.com/zarr-developers/zarr-python/pull/1692is_total_slice for size-1 dimensions by @dcherian in https://github.com/zarr-developers/zarr-python/pull/1800group.members by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/1726zarr.group by @dstansby in https://github.com/zarr-developers/zarr-python/pull/1870Buffer and NDBuffer by @madsbk in https://github.com/zarr-developers/zarr-python/pull/1899parse_shapelike allows 0 by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/1979RemoteStore.__str__ and add UPath tests by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/1964Buffer ensure correct subclass based on the BufferPrototype argument by @madsbk in https://github.com/zarr-developers/zarr-python/pull/1974make_store_path by @tomwhite in https://github.com/zarr-developers/zarr-python/pull/1992tests by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/1813Group.array and data kwarg to array creation by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/2042create_array signatures in group/asyncgroup classes by @jhamman in https://github.com/zarr-developers/zarr-python/pull/2132store argument by @TomAugspurger in https://github.com/zarr-developers/zarr-python/pull/2164to_dict always returns a dict, and v2 filter / compressor parsing by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/2179store.list_prefix and store._set_many by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/2064map(str, *) in test_accessed_chunks by @jakirkham in https://github.com/zarr-developers/zarr-python/pull/2229Stores by @TomAugspurger in https://github.com/zarr-developers/zarr-python/pull/2249zarr_format=2 by @TomAugspurger in https://github.com/zarr-developers/zarr-python/pull/2286string and bytes dtypes plus vlen-utf8 and vlen-bytes codecs by @rabernat in https://github.com/zarr-developers/zarr-python/pull/2036str dtype in array creation by @TomAugspurger in https://github.com/zarr-developers/zarr-python/pull/2323shape by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/2376AsyncGenerator should not yield None by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/2464{...!s} by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/2471zarr.core.group by @brokkoli71 in https://github.com/zarr-developers/zarr-python/pull/2452zarr.store → zarr.storage by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/2523test_vindex by @dstansby in https://github.com/zarr-developers/zarr-python/pull/2651Group.array() with data argument by @tomwhite in https://github.com/zarr-developers/zarr-python/pull/2668Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.16.1...v3.0.0
3.0.0 is a new major release of Zarr-Python, with many breaking changes. See the v3 migration guide for a listing of what's changed.
Normal release note service will resume with further releases in the 3.0.0 series.
Release notes for the zarr-python 2.x and 1.x releases can be found here: https://zarr.readthedocs.io/en/support-v2/release.html
Move deprecation notices to the top of docstrings by @dstansby in https://github.com/zarr-developers/zarr-python/pull/2637
test_vindex by @dstansby in https://github.com/zarr-developers/zarr-python/pull/2651Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.0-rc.1...v3.0.0-rc.2
[v3] implement / deprecate zarr.tree by @jhamman in https://github.com/zarr-developers/zarr-python/pull/2537
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.0-beta.3...v3.0.0-rc.1
fix open_array for mode r+ by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/2494
zarr.core.group by @brokkoli71 in https://github.com/zarr-developers/zarr-python/pull/2452zarr.store → zarr.storage by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/2523Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.0-beta.2...v3.0.0-beta.3
fix(group): deprecate positional args in Group.{zeros,ones,etc.} by @jhamman in https://github.com/zarr-developers/zarr-python/pull/2416
AsyncGenerator should not yield None by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/2464{...!s} by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/2471Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.0-beta.1...v3.0.0-beta.2
Update deprecated stage names by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/2362
shape by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/2376Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.0-beta...v3.0.0-beta.1
Deprecate the experimental v3 implementation by @jhamman in https://github.com/zarr-developers/zarr-python/pull/1802
is_total_slice for size-1 dimensions by @dcherian in https://github.com/zarr-developers/zarr-python/pull/1800zarr_format=2 by @TomAugspurger in https://github.com/zarr-developers/zarr-python/pull/2286string and bytes dtypes plus vlen-utf8 and vlen-bytes codecs by @rabernat in https://github.com/zarr-developers/zarr-python/pull/2036str dtype in array creation by @TomAugspurger in https://github.com/zarr-developers/zarr-python/pull/2323Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.0-alpha7...v3.0.0-beta
Bump verison of autoapi used to build docs by @dstansby in https://github.com/zarr-developers/zarr-python/pull/2177
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.0-alpha.6...v3.0.0-alpha7
fix typo in store integration test by @dcherian in https://github.com/zarr-developers/zarr-python/pull/2223
map(str, *) in test_accessed_chunks by @jakirkham in https://github.com/zarr-developers/zarr-python/pull/2229Stores by @TomAugspurger in https://github.com/zarr-developers/zarr-python/pull/2249Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.0-alpha.5...v3.0.0-alpha.6
test: check that store, array, and group classes are serializable by @jhamman in https://github.com/zarr-developers/zarr-python/pull/2006
to_dict always returns a dict, and v2 filter / compressor parsing by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/2179store.list_prefix and store._set_many by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/2064Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.0-alpha.4...v3.0.0-alpha.5
Fix new ruff/flake8-type-checking TCH003 error by @DimitriPapadopoulos in https://github.com/zarr-developers/zarr-python/pull/2154
store argument by @TomAugspurger in https://github.com/zarr-developers/zarr-python/pull/2164Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.0-alpha.3...v3.0.0-alpha.4
Bump pypa/gh-action-pypi-publish from 1.9.0 to 1.10.0 in the actions group by @dependabot in https://github.com/zarr-developers/zarr-python/pull/2147
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.0-alpha.2...v3.0.0-alpha.3
Fixed MemoryStore.list_dir by @TomAugspurger in https://github.com/zarr-developers/zarr-python/pull/2117
create_array signatures in group/asyncgroup classes by @jhamman in https://github.com/zarr-developers/zarr-python/pull/2132Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.0-alpha.1...v3.0.0-alpha.2
chore: update pre-commit hooks by @pre-commit-ci in https://github.com/zarr-developers/zarr-python/pull/1957
parse_shapelike allows 0 by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/1979RemoteStore.__str__ and add UPath tests by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/1964Buffer ensure correct subclass based on the BufferPrototype argument by @madsbk in https://github.com/zarr-developers/zarr-python/pull/1974make_store_path by @tomwhite in https://github.com/zarr-developers/zarr-python/pull/1992tests by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/1813Group.array and data kwarg to array creation by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/2042Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v3.0.0-alpha...v3.0.0-alpha.1
Disable pre-commit.ci's PR autofixes by @jakirkham in https://github.com/zarr-developers/zarr-python/pull/1506
CODE_OF_CONDCUT.md file from the Zarr-Python repo by @MSanKeys963 in https://github.com/zarr-developers/zarr-python/pull/1572hatch for packaging by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/1592v3 branch by @DahnJ in https://github.com/zarr-developers/zarr-python/pull/1692group.members by @d-v-b in https://github.com/zarr-developers/zarr-python/pull/1726zarr.group by @dstansby in https://github.com/zarr-developers/zarr-python/pull/1870Buffer and NDBuffer by @madsbk in https://github.com/zarr-developers/zarr-python/pull/1899Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.16.1...v3.0.0-alpha
Add a test with up to date dependencies & fix zarr-python v2 by @dstansby in https://github.com/zarr-developers/zarr-python/pull/2973
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.18.6...v2.18.7
Bump actions/setup-python from 5.4.0 to 5.5.0 in the actions group by @dependabot in https://github.com/zarr-developers/zarr-python/pull/2940
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.18.5...v2.18.6
Deprecate partial read/writes in v2 by @dstansby in https://github.com/zarr-developers/zarr-python/pull/2844
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.18.4...v2.18.5
[docs] remove primary sidebar from tutorial by @sneakers-the-rat in https://github.com/zarr-developers/zarr-python/pull/2142
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.18.3...v2.18.4
Deprecate N5Store by @jhamman in https://github.com/zarr-developers/zarr-python/pull/2103
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.18.2...v2.18.3
reset release notes by @jhamman in https://github.com/zarr-developers/zarr-python/pull/1886
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.18.1...v2.18.2
Update release.rst by @jhamman in https://github.com/zarr-developers/zarr-python/pull/1850
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.18.0...v2.18.1
Deprecate the experimental v3 implementation by @jhamman in https://github.com/zarr-developers/zarr-python/pull/1802
is_total_slice for size-1 dimensions by @dcherian in https://github.com/zarr-developers/zarr-python/pull/1800Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.17.2...v2.18.0
See release notes: https://zarr.readthedocs.io/en/stable/release.html#release-2-17-2
See release notes: https://zarr.readthedocs.io/en/stable/release.html#release-2-17-2
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.17.1...v2.17.2
See release notes: https://zarr.readthedocs.io/en/stable/release.html#release-2-17-1
See release notes: https://zarr.readthedocs.io/en/stable/release.html#release-2-17-1
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.17.0...v2.17.1
See release notes: https://zarr.readthedocs.io/en/stable/release.html#release-2-17-0
See release notes: https://zarr.readthedocs.io/en/stable/release.html#release-2-17-0
CODE_OF_CONDCUT.md file from the Zarr-Python repo by @MSanKeys963 in https://github.com/zarr-developers/zarr-python/pull/1572Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.16.1...v2.17.0
See release notes: https://zarr.readthedocs.io/en/stable/release.html#release-2-16-1
See release notes: https://zarr.readthedocs.io/en/stable/release.html#release-2-16-1
setuptools_scm version 1.5.4+ by @jakirkham in https://github.com/zarr-developers/zarr-python/pull/1477docs requirements to pyproject.toml by @jakirkham in https://github.com/zarr-developers/zarr-python/pull/1494zarr.group now accept the meta_array argument by @madsbk in https://github.com/zarr-developers/zarr-python/pull/1489LRUStoreCache: cache "contains" by contains checks by @madsbk in https://github.com/zarr-developers/zarr-python/pull/1499Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.16.0...v2.16.1
See release notes https://zarr.readthedocs.io/en/stable/release.html#release-2-16-0
See release notes https://zarr.readthedocs.io/en/stable/release.html#release-2-16-0
Full Changelog: https://github.com/zarr-developers/zarr-python/compare/v2.15.0...v2.16.0
Your coding agent can read these notes before it upgrades. Set up the MCP server →