def __init__(self, store, path=None, read_only=False, chunk_store=None,
cache_attrs=True, synchronizer=None):
self._store = store
self._chunk_store = chunk_store
self._path = normalize_storage_path(path)
if self._path:
self._key_prefix = self._path + '/'
else:
self._key_prefix = ''
self._read_only = read_only
self._synchronizer = synchronizer
# guard conditions
if contains_array(store, path=self._path):
raise ContainsArrayError(path)
# initialize metadata
try:
mkey = self._key_prefix + group_meta_key
meta_bytes = store[mkey]
except KeyError:
raise GroupNotFoundError(path)
else:
meta = decode_group_metadata(meta_bytes)
self._meta = meta
# setup attributes
akey = self._key_prefix + attrs_key
self._attrs = Attributes(store, key=akey, read_only=read_only,
cache=cache_attrs, synchronizer=synchronizer)
# setup info
self._info = InfoReporter(self)
def __getitem__(self, __key: Optional[str]) -> Optional[xr.Dataset]:
if self._tree:
try:
node = self.__get_node(__key)
return self.__get_dataset(node)
except ChildResolverError:
raise GroupNotFoundError(__key)
else:
raise ValueError("Datatree not found!")
def open_group(store=None,
mode='a',
cache_attrs=True,
synchronizer=None,
path=None,
chunk_store=None,
storage_options=None):
"""Open a group using file-mode-like semantics.
Parameters
----------
store : MutableMapping or string, optional
Store or path to directory in file system or name of zip file.
mode : {'r', 'r+', 'a', 'w', 'w-'}, optional
Persistence mode: 'r' means read only (must exist); 'r+' means
read/write (must exist); 'a' means read/write (create if doesn't
exist); 'w' means create (overwrite if exists); 'w-' means create
(fail if exists).
cache_attrs : bool, optional
If True (default), user attributes will be cached for attribute read
operations. If False, user attributes are reloaded from the store prior
to all attribute read operations.
synchronizer : object, optional
Array synchronizer.
path : string, optional
Group path within store.
chunk_store : MutableMapping or string, optional
Store or path to directory in file system or name of zip file.
storage_options : dict
If using an fsspec URL to create the store, these will be passed to
the backend implementation. Ignored otherwise.
Returns
-------
g : zarr.hierarchy.Group
Examples
--------
>>> import zarr
>>> root = zarr.open_group('data/example.zarr', mode='w')
>>> foo = root.create_group('foo')
>>> bar = root.create_group('bar')
>>> root
<zarr.hierarchy.Group '/'>
>>> root2 = zarr.open_group('data/example.zarr', mode='a')
>>> root2
<zarr.hierarchy.Group '/'>
>>> root == root2
True
"""
# handle polymorphic store arg
clobber = mode != 'r'
store = _normalize_store_arg(store,
clobber=clobber,
storage_options=storage_options)
if chunk_store is not None:
chunk_store = _normalize_store_arg(chunk_store,
clobber=clobber,
storage_options=storage_options)
path = normalize_storage_path(path)
# ensure store is initialized
if mode in ['r', 'r+']:
if contains_array(store, path=path):
raise ContainsArrayError(path)
elif not contains_group(store, path=path):
raise GroupNotFoundError(path)
elif mode == 'w':
init_group(store, overwrite=True, path=path, chunk_store=chunk_store)
elif mode == 'a':
if contains_array(store, path=path):
raise ContainsArrayError(path)
if not contains_group(store, path=path):
init_group(store, path=path, chunk_store=chunk_store)
elif mode in ['w-', 'x']:
if contains_array(store, path=path):
raise ContainsArrayError(path)
elif contains_group(store, path=path):
raise ContainsGroupError(path)
else:
init_group(store, path=path, chunk_store=chunk_store)
# determine read only status
read_only = mode == 'r'
return Group(store,
read_only=read_only,
cache_attrs=cache_attrs,
synchronizer=synchronizer,
path=path,
chunk_store=chunk_store)
def __init__(self,
store,
path=None,
read_only=False,
chunk_store=None,
cache_attrs=True,
synchronizer=None,
zarr_version=None):
store: BaseStore = _normalize_store_arg(store,
zarr_version=zarr_version)
if zarr_version is None:
zarr_version = getattr(store, '_store_version',
DEFAULT_ZARR_VERSION)
if chunk_store is not None:
chunk_store: BaseStore = _normalize_store_arg(
chunk_store, zarr_version=zarr_version)
self._store = store
self._chunk_store = chunk_store
self._path = normalize_storage_path(path)
if self._path:
self._key_prefix = self._path + '/'
else:
self._key_prefix = ''
self._read_only = read_only
self._synchronizer = synchronizer
self._version = zarr_version
if self._version == 3:
self._data_key_prefix = data_root + self._key_prefix
self._data_path = data_root + self._path
self._hierarchy_metadata = _get_hierarchy_metadata(
store=self._store)
self._metadata_key_suffix = _get_metadata_suffix(store=self._store)
# guard conditions
if contains_array(store, path=self._path):
raise ContainsArrayError(path)
# initialize metadata
try:
mkey = _prefix_to_group_key(self._store, self._key_prefix)
assert not mkey.endswith("root/.group")
meta_bytes = store[mkey]
except KeyError:
if self._version == 2:
raise GroupNotFoundError(path)
else:
implicit_prefix = meta_root + self._key_prefix
if self._store.list_prefix(implicit_prefix):
# implicit group does not have any metadata
self._meta = None
else:
raise GroupNotFoundError(path)
else:
self._meta = self._store._metadata_class.decode_group_metadata(
meta_bytes)
# setup attributes
if self._version == 2:
akey = self._key_prefix + attrs_key
else:
# Note: mkey doesn't actually exist for implicit groups, but the
# object can still be created.
akey = mkey
self._attrs = Attributes(store,
key=akey,
read_only=read_only,
cache=cache_attrs,
synchronizer=synchronizer)
# setup info
self._info = InfoReporter(self)