Use modify metadata to undo all compression. This uses a third-party compression filter, which adds nuance because h5py.Dataset.compression re

Use modify metadata to undo all compression.

Test calling modify_metadata() to change both dtype and fillvalue, and the new fillvalue would not fit in the old dtype, so it needs to be upd

Test changing fletcher32, scaleoffset, shuffle parameters.

Make sure the virtual datasets do not hard-code the filename

Each chunk's digest lands in the row named by hash_rows; unlisted rows stay untouched.

Test that flipping the buffer multiple times between object and StringDType raises a warning.

Chunks are deduplicated by raw bytes, not by value: two chunks of NaNs with the same bit pattern hash the same, even though they compare unequal

Chunks carved out of the same slab with the same number of identical elements, but different edge-trimmed shapes, hash differently. The data

Chunks of different shapes hashed in a single hash_slab call don't contaminate each other; the shape suffix of one chunk must not leak into the ne

The same six values, arranged in different shapes, hash differently. Every reshape below is C-contiguous, so the data bytes are byte-for-byte the

Data bytes that spell out a shape string can't be used to forge the shape suffix, no matter how they line up with the real one.

+0.0 and -0.0 compare equal, but they are not the same chunk.

A variable-width string that spells out its own length prefix can't be used to forge the element boundaries.

Empty strings, and strings made of NUL bytes, are all distinguished from each other and from their own repetitions.

Moving the boundaries between variable-width strings, without changing their concatenation, changes the hash.

A StringDType array and the equivalent object-of-str array hash identically

Test when input parameters are numpy.int types instead of plain python ints

Test when input parameters are numpy.int types instead of plain python ints

Test that object dtype arrays hash values which concatenate to the same string to different hashes. See https://github.com/deshaw/versioned-hd

Test that object dtype arrays hash values, not element ids. See https://github.com/deshaw/versioned-hdf5/issues/256 for more information.

Test the end-to-end use case ``group[name] = np.array([...], dtype=object)``: assignment of a bare object dtype array, stripped of the h5py st

Test that invalid compression types do not validate.

Test that the src array can be anything that implements ArrayProtocol

1D indices are automatically broadcast to 2D

Counts are clipped automatically because either dst_start or dst_stride are too large. This causes some slices to become size 0 along one dime

Counts are clipped automatically because either src_start or src_stride are too large. This causes some slices to become size 0 along one dime

dst array has size 0

read_many_slices uses the hdf5 C API for the memory layouts H5Sselect_hyperslab can describe and falls back to the pure-python transfer for the re

Edge case where there are no slices of data to copy

one or more coordinate array is not C-contiguous along the rows or both columns and rows. Non-contiguous rows are supported thanks to Cython

src is a h5py dataset that doesn't support fast read

src array has size 0

Read-only data is copied upon creation of a new version.

Verify rebuilding the hashtable for a single object dtype and single version. 1. An info log message is issued to the user about DATA_VERSION mis

Test that the correct chunks are used after rebuilding the tables.

Test that the correct chunks are used after rebuilding the tables for a multi-dimensional array.

Test that the correct chunks are used after rebuilding the tables for non-ascii data.

Verify rebuilding the hashtable for multiple datasets across multiple versions. 1. An info log message is issued to the user about DATA_VERSION m

Test rebuilding the hash tables of a nested dataset.

Test rebuilding the hash tables of a nested dataset.

recreate_dataset() streams the chunks of a committed dataset from the raw_data of the source group into the raw_data of the target group, instead

recreate_dataset() rewrites every version of a dataset into a brand new group. When its callback returns an InMemoryDataset, the StagedChangesArra

recreate_dataset() rewrites each version a block of chunks at a time, so that peak memory usage doesn't scale with the size of the dataset. Neithe

refill() changes chunk dtype upon first access. This happens **before** the new fill_value is applied, to avoid overflows or loss of d

Enlarge or shrink partial edge chunks along an axis while another axis is size 0, so that no chunks are actually transferred.

rewrite_dataset() copies every chunk of an array into a brand new raw_data, deduplicating them, and returns the same {virtual index: raw_data slic

A size-0 dataset has no chunks to rewrite.

Scalar (ndim=0) datasets are supported by h5py, but implementing them in versioned_hdf5 would take a lot of special-casing as raw_data can't go be