def test_create_read_only(zarr_version):
# https://github.com/alimanfoo/zarr/issues/151
kwargs = _init_creation_kwargs(zarr_version)
# create an array initially read-only, then enable writing
z = create(100, read_only=True, **kwargs)
assert z.read_only
with pytest.raises(PermissionError):
z[:] = 42
z.read_only = False
z[:] = 42
assert np.all(z[...] == 42)
z.read_only = True
with pytest.raises(PermissionError):
z[:] = 0
# this is subtly different, but here we want to create an array with data, and then
# have it be read-only
a = np.arange(100)
z = array(a, read_only=True, **kwargs)
assert_array_equal(a, z[...])
assert z.read_only
with pytest.raises(PermissionError):
z[:] = 42
def _create_nosync(self, name, **kwargs):
path = self._item_path(name)
kwargs.setdefault('synchronizer', self._synchronizer)
return create(store=self._store,
path=path,
chunk_store=self._chunk_store,
**kwargs)
def test_create():
# defaults
z = create(100)
assert_is_instance(z, Array)
eq((100, ), z.shape)
eq((100, ), z.chunks) # auto-chunks
eq(np.dtype(None), z.dtype)
eq('blosc', z.compressor.codec_id)
eq(0, z.fill_value)
# all specified
z = create(100,
chunks=10,
dtype='i4',
compressor=Zlib(1),
fill_value=42,
order='F')
assert_is_instance(z, Array)
eq((100, ), z.shape)
eq((10, ), z.chunks)
eq(np.dtype('i4'), z.dtype)
eq('zlib', z.compressor.codec_id)
eq(1, z.compressor.level)
eq(42, z.fill_value)
eq('F', z.order)
# with synchronizer
synchronizer = ThreadSynchronizer()
z = create(100, chunks=10, synchronizer=synchronizer)
assert_is_instance(z, Array)
eq((100, ), z.shape)
eq((10, ), z.chunks)
assert synchronizer is z.synchronizer
# don't allow string as compressor arg
with assert_raises(ValueError):
create(100, chunks=10, compressor='zlib')
# compatibility
z = create(100, compression='zlib', compression_opts=9)
eq('zlib', z.compressor.codec_id)
eq(9, z.compressor.level)
z = create(100, compression='default')
eq('blosc', z.compressor.codec_id)
# errors
with assert_raises(ValueError):
create(100, compression=1)
def test_compression_args():
z = create(100, compression='zlib', compression_opts=9)
assert isinstance(z, Array)
assert 'zlib' == z.compressor.codec_id
assert 9 == z.compressor.level
# 'compressor' overrides 'compression'
z = create(100, compressor=Zlib(9), compression='bz2', compression_opts=1)
assert isinstance(z, Array)
assert 'zlib' == z.compressor.codec_id
assert 9 == z.compressor.level
# 'compressor' ignores 'compression_opts'
z = create(100, compressor=Zlib(9), compression_opts=1)
assert isinstance(z, Array)
assert 'zlib' == z.compressor.codec_id
assert 9 == z.compressor.level
# cannot get warning tests to work on PY2
if not PY2: # pragma: py2 no cover
with pytest.warns(UserWarning):
# 'compressor' overrides 'compression'
create(100,
compressor=Zlib(9),
compression='bz2',
compression_opts=1)
with pytest.warns(UserWarning):
# 'compressor' ignores 'compression_opts'
create(100, compressor=Zlib(9), compression_opts=1)
def test_compression_args():
warnings.resetwarnings()
warnings.simplefilter('always')
z = create(100, compression='zlib', compression_opts=9)
assert_is_instance(z, Array)
eq('zlib', z.compressor.codec_id)
eq(9, z.compressor.level)
# 'compressor' overrides 'compression'
z = create(100, compressor=Zlib(9), compression='bz2', compression_opts=1)
assert_is_instance(z, Array)
eq('zlib', z.compressor.codec_id)
eq(9, z.compressor.level)
# 'compressor' ignores 'compression_opts'
z = create(100, compressor=Zlib(9), compression_opts=1)
assert_is_instance(z, Array)
eq('zlib', z.compressor.codec_id)
eq(9, z.compressor.level)
warnings.resetwarnings()
warnings.simplefilter('error')
with assert_raises(UserWarning):
# 'compressor' overrides 'compression'
create(100, compressor=Zlib(9), compression='bz2', compression_opts=1)
with assert_raises(UserWarning):
# 'compressor' ignores 'compression_opts'
create(100, compressor=Zlib(9), compression_opts=1)
warnings.resetwarnings()
warnings.simplefilter('always')
def test_compression_args():
z = create(100, compression='zlib', compression_opts=9)
assert isinstance(z, Array)
assert 'zlib' == z.compressor.codec_id
assert 9 == z.compressor.level
# 'compressor' overrides 'compression'
z = create(100, compressor=Zlib(9), compression='bz2', compression_opts=1)
assert isinstance(z, Array)
assert 'zlib' == z.compressor.codec_id
assert 9 == z.compressor.level
# 'compressor' ignores 'compression_opts'
z = create(100, compressor=Zlib(9), compression_opts=1)
assert isinstance(z, Array)
assert 'zlib' == z.compressor.codec_id
assert 9 == z.compressor.level
with pytest.warns(UserWarning):
# 'compressor' overrides 'compression'
create(100, compressor=Zlib(9), compression='bz2', compression_opts=1)
with pytest.warns(UserWarning):
# 'compressor' ignores 'compression_opts'
create(100, compressor=Zlib(9), compression_opts=1)
def test_compression_args():
z = create(100, compression='zlib', compression_opts=9)
assert isinstance(z, Array)
assert 'zlib' == z.compressor.codec_id
assert 9 == z.compressor.level
# 'compressor' overrides 'compression'
z = create(100, compressor=Zlib(9), compression='bz2', compression_opts=1)
assert isinstance(z, Array)
assert 'zlib' == z.compressor.codec_id
assert 9 == z.compressor.level
# 'compressor' ignores 'compression_opts'
z = create(100, compressor=Zlib(9), compression_opts=1)
assert isinstance(z, Array)
assert 'zlib' == z.compressor.codec_id
assert 9 == z.compressor.level
with pytest.warns(UserWarning):
# 'compressor' overrides 'compression'
create(100, compressor=Zlib(9), compression='bz2', compression_opts=1)
with pytest.warns(UserWarning):
# 'compressor' ignores 'compression_opts'
create(100, compressor=Zlib(9), compression_opts=1)
def test_compression_args():
z = create(100, compression='zlib', compression_opts=9)
assert_is_instance(z, Array)
eq('zlib', z.compressor.codec_id)
eq(9, z.compressor.level)
# 'compressor' overrides 'compression'
z = create(100, compressor=Zlib(9), compression='bz2', compression_opts=1)
assert_is_instance(z, Array)
eq('zlib', z.compressor.codec_id)
eq(9, z.compressor.level)
# 'compressor' ignores 'compression_opts'
z = create(100, compressor=Zlib(9), compression_opts=1)
assert_is_instance(z, Array)
eq('zlib', z.compressor.codec_id)
eq(9, z.compressor.level)
with pytest.warns(UserWarning):
# 'compressor' overrides 'compression'
create(100, compressor=Zlib(9), compression='bz2', compression_opts=1)
with pytest.warns(UserWarning):
# 'compressor' ignores 'compression_opts'
create(100, compressor=Zlib(9), compression_opts=1)
def test_compression_args():
with warnings.catch_warnings():
warnings.simplefilter("default")
z = create(100, compression="zlib", compression_opts=9)
assert isinstance(z, Array)
assert "zlib" == z.compressor.codec_id
assert 9 == z.compressor.level
# 'compressor' overrides 'compression'
with pytest.warns(UserWarning):
z = create(100,
compressor=Zlib(9),
compression="bz2",
compression_opts=1)
assert isinstance(z, Array)
assert "zlib" == z.compressor.codec_id
assert 9 == z.compressor.level
# 'compressor' ignores 'compression_opts'
with pytest.warns(UserWarning):
z = create(100, compressor=Zlib(9), compression_opts=1)
assert isinstance(z, Array)
assert "zlib" == z.compressor.codec_id
assert 9 == z.compressor.level
with pytest.warns(UserWarning):
# 'compressor' overrides 'compression'
create(100,
compressor=Zlib(9),
compression="bz2",
compression_opts=1)
with pytest.warns(UserWarning):
# 'compressor' ignores 'compression_opts'
create(100, compressor=Zlib(9), compression_opts=1)
def test_compression_args():
z = create(100, compression='zlib', compression_opts=9)
assert_is_instance(z, Array)
eq('zlib', z.compressor.codec_id)
eq(9, z.compressor.level)
# 'compressor' overrides 'compression'
z = create(100, compressor=Zlib(9), compression='bz2', compression_opts=1)
assert_is_instance(z, Array)
eq('zlib', z.compressor.codec_id)
eq(9, z.compressor.level)
# 'compressor' ignores 'compression_opts'
z = create(100, compressor=Zlib(9), compression_opts=1)
assert_is_instance(z, Array)
eq('zlib', z.compressor.codec_id)
eq(9, z.compressor.level)
def test_create():
# defaults
z = create(100)
assert_is_instance(z, Array)
eq((100,), z.shape)
eq((100,), z.chunks) # auto-chunks
eq(np.dtype(None), z.dtype)
eq('blosc', z.compressor.codec_id)
eq(0, z.fill_value)
# all specified
z = create(100, chunks=10, dtype='i4', compressor=Zlib(1),
fill_value=42, order='F')
assert_is_instance(z, Array)
eq((100,), z.shape)
eq((10,), z.chunks)
eq(np.dtype('i4'), z.dtype)
eq('zlib', z.compressor.codec_id)
eq(1, z.compressor.level)
eq(42, z.fill_value)
eq('F', z.order)
# with synchronizer
synchronizer = ThreadSynchronizer()
z = create(100, chunks=10, synchronizer=synchronizer)
assert_is_instance(z, Array)
eq((100,), z.shape)
eq((10,), z.chunks)
assert synchronizer is z.synchronizer
# don't allow string as compressor arg
with assert_raises(ValueError):
create(100, chunks=10, compressor='zlib')
# compatibility
z = create(100, compression='zlib', compression_opts=9)
eq('zlib', z.compressor.codec_id)
eq(9, z.compressor.level)
z = create(100, compression='default')
eq('blosc', z.compressor.codec_id)
# errors
with assert_raises(ValueError):
create(100, compression=1)
def _create_dataset_nosync(self, name, data=None, **kwargs):
path = self._item_path(name)
# determine synchronizer
kwargs.setdefault('synchronizer', self._synchronizer)
# create array
if data is None:
a = create(store=self._store, path=path,
chunk_store=self._chunk_store, **kwargs)
else:
a = array(data, store=self._store, path=path,
chunk_store=self._chunk_store, **kwargs)
return a
def _create_dataset_nosync(self, name, data=None, **kwargs):
path = self._item_path(name)
# determine synchronizer
kwargs.setdefault('synchronizer', self._synchronizer)
kwargs.setdefault('cache_attrs', self.attrs.cache)
# create array
if data is None:
a = create(store=self._store, path=path, chunk_store=self._chunk_store,
**kwargs)
else:
a = array(data, store=self._store, path=path, chunk_store=self._chunk_store,
**kwargs)
return a
def test_create_read_only():
# https://github.com/alimanfoo/zarr/issues/151
# create an array initially read-only, then enable writing
z = create(100, read_only=True)
assert z.read_only
with assert_raises(PermissionError):
z[:] = 42
z.read_only = False
z[:] = 42
assert np.all(z[...] == 42)
z.read_only = True
with assert_raises(PermissionError):
z[:] = 0
# this is subtly different, but here we want to create an array with data, and then
# have it be read-only
a = np.arange(100)
z = array(a, read_only=True)
assert_array_equal(a, z[...])
assert z.read_only
with assert_raises(PermissionError):
z[:] = 42
def test_create(zarr_version):
kwargs = _init_creation_kwargs(zarr_version)
expected_zarr_version = DEFAULT_ZARR_VERSION if zarr_version is None else zarr_version
# defaults
z = create(100, **kwargs)
if zarr_version == 3:
with pytest.raises(ValueError):
# cannot create without specifying a path
z = create(100, zarr_version=3)
assert isinstance(z, Array)
assert (100, ) == z.shape
assert (100, ) == z.chunks # auto-chunks
assert np.dtype(None) == z.dtype
assert 'blosc' == z.compressor.codec_id
assert 0 == z.fill_value
assert z._store._store_version == expected_zarr_version
# all specified
z = create(100,
chunks=10,
dtype='i4',
compressor=Zlib(1),
fill_value=42,
order='F',
**kwargs)
assert isinstance(z, Array)
assert (100, ) == z.shape
assert (10, ) == z.chunks
assert np.dtype('i4') == z.dtype
assert 'zlib' == z.compressor.codec_id
assert 1 == z.compressor.level
assert 42 == z.fill_value
assert 'F' == z.order
assert z._store._store_version == expected_zarr_version
# with synchronizer
synchronizer = ThreadSynchronizer()
z = create(100, chunks=10, synchronizer=synchronizer, **kwargs)
assert isinstance(z, Array)
assert (100, ) == z.shape
assert (10, ) == z.chunks
assert synchronizer is z.synchronizer
assert z._store._store_version == expected_zarr_version
# don't allow string as compressor arg
with pytest.raises(ValueError):
create(100, chunks=10, compressor='zlib', **kwargs)
# h5py compatibility
z = create(100, compression='zlib', compression_opts=9, **kwargs)
assert 'zlib' == z.compressor.codec_id
assert 9 == z.compressor.level
z = create(100, compression='default', **kwargs)
assert 'blosc' == z.compressor.codec_id
# errors
with pytest.raises(ValueError):
# bad compression argument
create(100, compression=1, **kwargs)
with pytest.raises(ValueError):
# bad fill value
create(100, dtype='i4', fill_value='foo', **kwargs)
# auto chunks
z = create(1000000000, chunks=True, **kwargs)
assert z.chunks[0] < z.shape[0]
z = create(1000000000, chunks=None, **kwargs) # backwards-compatibility
assert z.chunks[0] < z.shape[0]
# no chunks
z = create(1000000000, chunks=False, **kwargs)
assert z.chunks == z.shape
def test_create():
# defaults
z = create(100)
assert isinstance(z, Array)
assert (100, ) == z.shape
assert (100, ) == z.chunks # auto-chunks
assert np.dtype(None) == z.dtype
assert 'blosc' == z.compressor.codec_id
assert 0 == z.fill_value
# all specified
z = create(100,
chunks=10,
dtype='i4',
compressor=Zlib(1),
fill_value=42,
order='F')
assert isinstance(z, Array)
assert (100, ) == z.shape
assert (10, ) == z.chunks
assert np.dtype('i4') == z.dtype
assert 'zlib' == z.compressor.codec_id
assert 1 == z.compressor.level
assert 42 == z.fill_value
assert 'F' == z.order
# with synchronizer
synchronizer = ThreadSynchronizer()
z = create(100, chunks=10, synchronizer=synchronizer)
assert isinstance(z, Array)
assert (100, ) == z.shape
assert (10, ) == z.chunks
assert synchronizer is z.synchronizer
# don't allow string as compressor arg
with pytest.raises(ValueError):
create(100, chunks=10, compressor='zlib')
# h5py compatibility
z = create(100, compression='zlib', compression_opts=9)
assert 'zlib' == z.compressor.codec_id
assert 9 == z.compressor.level
z = create(100, compression='default')
assert 'blosc' == z.compressor.codec_id
# errors
with pytest.raises(ValueError):
# bad compression argument
create(100, compression=1)
with pytest.raises(ValueError):
# bad fill value
create(100, dtype='i4', fill_value='foo')
# auto chunks
z = create(1000000000, chunks=True)
assert z.chunks[0] < z.shape[0]
z = create(1000000000, chunks=None) # backwards-compatibility
assert z.chunks[0] < z.shape[0]
# no chunks
z = create(1000000000, chunks=False)
assert z.chunks == z.shape
def _create_nosync(self, name, **kwargs):
path = self._item_path(name)
kwargs.setdefault('synchronizer', self._synchronizer)
return create(store=self._store, path=path,
chunk_store=self._chunk_store, **kwargs)
def test_create():
# defaults
z = create(100)
assert isinstance(z, Array)
assert (100,) == z.shape
assert (100,) == z.chunks # auto-chunks
assert np.dtype(None) == z.dtype
assert 'blosc' == z.compressor.codec_id
assert 0 == z.fill_value
# all specified
z = create(100, chunks=10, dtype='i4', compressor=Zlib(1),
fill_value=42, order='F')
assert isinstance(z, Array)
assert (100,) == z.shape
assert (10,) == z.chunks
assert np.dtype('i4') == z.dtype
assert 'zlib' == z.compressor.codec_id
assert 1 == z.compressor.level
assert 42 == z.fill_value
assert 'F' == z.order
# with synchronizer
synchronizer = ThreadSynchronizer()
z = create(100, chunks=10, synchronizer=synchronizer)
assert isinstance(z, Array)
assert (100,) == z.shape
assert (10,) == z.chunks
assert synchronizer is z.synchronizer
# don't allow string as compressor arg
with pytest.raises(ValueError):
create(100, chunks=10, compressor='zlib')
# h5py compatibility
z = create(100, compression='zlib', compression_opts=9)
assert 'zlib' == z.compressor.codec_id
assert 9 == z.compressor.level
z = create(100, compression='default')
assert 'blosc' == z.compressor.codec_id
# errors
with pytest.raises(ValueError):
# bad compression argument
create(100, compression=1)
with pytest.raises(ValueError):
# bad fill value
create(100, dtype='i4', fill_value='foo')
# auto chunks
z = create(1000000000, chunks=True)
assert z.chunks[0] < z.shape[0]
z = create(1000000000, chunks=None) # backwards-compatibility
assert z.chunks[0] < z.shape[0]
# no chunks
z = create(1000000000, chunks=False)
assert z.chunks == z.shape
