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_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 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