imas-python 2.1.0.post1__py3-none-any.whl → 2.3.0__py3-none-any.whl

imas/__init__.py

@@ -1,30 +1,58 @@
 # This file is part of IMAS-Python.
 # You should have received the IMAS-Python LICENSE file with this project.
 
-# isort: skip_file
-
 from packaging.version import Version as _V
 
-from ._version import version as __version__  # noqa: F401
-from ._version import version_tuple  # noqa: F401
-
 # Import logging _first_
-from . import setup_logging
+# isort: off
+from . import setup_logging  # noqa: F401
+
+# isort: on
 
-# Import main user API objects in the imas module
+# Ensure that `imas.util` is loaded when importing imas
+from . import util  # noqa: F401
+
+# Public API:
+from ._version import version as __version__
+from ._version import version_tuple
+from .convert_core_edge_plasma import (
+    convert_to_plasma_profiles,
+    convert_to_plasma_sources,
+    convert_to_plasma_transport,
+)
 from .db_entry import DBEntry
-from .ids_factory import IDSFactory
 from .ids_convert import convert_ids
+from .ids_data_type import IDSDataType
+from .ids_factory import IDSFactory
 from .ids_identifiers import identifiers
-
-# Load the IMAS-Python IMAS AL/DD core
-from . import (
-    db_entry,
-    dd_zip,
-    util,
-)
+from .ids_metadata import IDSMetadata, IDSType
+from .ids_primitive import IDSPrimitive
+from .ids_struct_array import IDSStructArray
+from .ids_structure import IDSStructure
+from .ids_toplevel import IDSToplevel
 
 PUBLISHED_DOCUMENTATION_ROOT = "https://imas-python.readthedocs.io/en/latest/"
 """URL to the published documentation."""
 OLDEST_SUPPORTED_VERSION = _V("3.22.0")
 """Oldest Data Dictionary version that is supported by IMAS-Python."""
+
+__all__ = [
+    "__version__",
+    "version_tuple",
+    "DBEntry",
+    "IDSDataType",
+    "IDSFactory",
+    "IDSMetadata",
+    "IDSPrimitive",
+    "IDSStructure",
+    "IDSStructArray",
+    "IDSToplevel",
+    "IDSType",
+    "convert_ids",
+    "convert_to_plasma_profiles",
+    "convert_to_plasma_sources",
+    "convert_to_plasma_transport",
+    "identifiers",
+    "PUBLISHED_DOCUMENTATION_ROOT",
+    "OLDEST_SUPPORTED_VERSION",
+]

imas/_to_xarray.py

@@ -8,7 +8,7 @@ from imas.backends.netcdf.ids_tensorizer import IDSTensorizer
 from imas.ids_data_type import IDSDataType
 
 fillvals = {
-    IDSDataType.INT: -(2**31) + 1,
+    IDSDataType.INT: numpy.int32(-(2**31) + 1),
     IDSDataType.STR: "",
     IDSDataType.FLT: numpy.nan,
     IDSDataType.CPX: numpy.nan * (1 + 1j),
@@ -27,7 +27,7 @@ def to_xarray(ids: IDSToplevel, *paths: str) -> xarray.Dataset:
     # block checks if the paths are valid, and by using "metadata.path_string" we ensure
     # that / are used as separator.
     try:
-        paths = [ids.metadata[path].path_string for path in paths]
+        paths: list[str] = [ids.metadata[path].path_string for path in paths]
     except KeyError as exc:
         raise ValueError(str(exc)) from None
 
@@ -50,21 +50,28 @@ def to_xarray(ids: IDSToplevel, *paths: str) -> xarray.Dataset:
         var_name = path.replace("/", ".")
         metadata = ids.metadata[path]
         if metadata.data_type in (IDSDataType.STRUCTURE, IDSDataType.STRUCT_ARRAY):
-            continue  # We don't store these in xarray
-
-        dimensions = tensorizer.ncmeta.get_dimensions(path, tensorizer.homogeneous_time)
-        data = tensorizer.tensorize(path, fillvals[metadata.data_type])
-
-        attrs = dict(documentation=metadata.documentation)
-        if metadata.units:
-            attrs["units"] = metadata.units
-        coordinates = tensorizer.filter_coordinates(path)
-        if coordinates:
-            coordinate_names.update(coordinates.split(" "))
-            attrs["coordinates"] = coordinates
+            # Metadata variables for (arrays of) structures
+            if paths and path not in paths:
+                continue
+            dimensions = ()
+            data = b""
+        else:
+            dimensions = tensorizer.get_dimensions(path)
+            data = tensorizer.tensorize(path, fillvals[metadata.data_type])
 
+        attrs = tensorizer.get_attributes(path, fillvals)
+        if "coordinates" in attrs:
+            coordinate_names.update(attrs["coordinates"].split(" "))
         data_vars[var_name] = (dimensions, data, attrs)
 
+        # :shape array for sparse data
+        if path in tensorizer.shapes and metadata.ndim:
+            shape_name = f"{var_name}:shape"
+            dimensions = tensorizer.get_shape_dimensions(path)
+            data = tensorizer.shapes[path]
+            attrs = tensorizer.get_shape_attributes(var_name)
+            data_vars[shape_name] = (dimensions, data, attrs)
+
     # Remove coordinates from data_vars and put in coordinates mapping:
     coordinates = {}
     for coordinate_name in coordinate_names:

imas/_version.py

@@ -1,5 +1,6 @@
-# file generated by setuptools-scm
+# file generated by vcs-versioning
 # don't change, don't track in version control
+from __future__ import annotations
 
 __all__ = [
     "__version__",
@@ -10,25 +11,14 @@ __all__ = [
     "commit_id",
 ]
 
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple
-    from typing import Union
-
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-    COMMIT_ID = Union[str, None]
-else:
-    VERSION_TUPLE = object
-    COMMIT_ID = object
-
 version: str
 __version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-commit_id: COMMIT_ID
-__commit_id__: COMMIT_ID
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
 
-__version__ = version = '2.1.0.post1'
-__version_tuple__ = version_tuple = (2, 1, 0, 'post1')
+__version__ = version = '2.3.0'
+__version_tuple__ = version_tuple = (2, 3, 0)
 
 __commit_id__ = commit_id = None

imas/assets/ITER_134173_106_equilibrium.ids

@@ -26,8 +26,6 @@ equilibrium/vacuum_toroidal_field/b0
 	dim: 1
 	size: 3 
 -5.2999999999999998e+00 -5.2999999999999998e+00 -5.2999999999999998e+00 
-equilibrium/grids_ggd
-	size: 1
 equilibrium/time_slice
 	size: 3
 equilibrium/time_slice[0]/boundary/outline/r

imas/assets/equilibrium.ids

@@ -26,8 +26,6 @@ equilibrium/vacuum_toroidal_field/b0
 	dim: 1
 	size: 3 
 -5.2999999999999998e+00 -5.2999999999999998e+00 -5.2999999999999998e+00 
-equilibrium/grids_ggd
-	size: 1
 equilibrium/time_slice
 	size: 3
 equilibrium/time_slice[0]/boundary/outline/r

imas/backends/db_entry_impl.py

@@ -78,7 +78,7 @@ class DBEntryImpl(ABC):
         destination: IDSToplevel,
         lazy: bool,
         nbc_map: Optional[NBCPathMap],
-    ) -> None:
+    ) -> IDSToplevel:
         """Implement DBEntry.get/get_slice/get_sample. Load data from the data source.
 
         Args:
@@ -120,3 +120,11 @@ class DBEntryImpl(ABC):
     @abstractmethod
     def list_all_occurrences(self, ids_name: str) -> List[int]:
         """Implement DBEntry.list_all_occurrences()"""
+
+    @abstractmethod
+    def list_filled_paths(self, ids_name: str, occurrence: int) -> List[str]:
+        """Implement DBEntry.list_filled_paths().
+
+        N.B. DD conversion is handled in DBEntry.list_filled_paths(), this method
+        returns the data paths as stored on-disk.
+        """

imas/backends/imas_core/al_context.py

@@ -115,7 +115,7 @@ class ALContext:
         tmin: float,
         tmax: float,
         dtime: Optional[numpy.ndarray],
-        interpolation_method: int,
+        interpolation_method: Optional[int],
     ) -> "ALContext":
         """Begin a new timerange action for use in a ``with`` context."""
         ctx = ll_interface.begin_timerange_action(
@@ -163,7 +163,7 @@ class ALContext:
         """Call ual_write_data with this context."""
         status = ll_interface.write_data(self.ctx, path, timebasepath, data)
         if status != 0:
-            raise LowlevelError(f"write data at {path!r}: {status=}")
+            raise LowlevelError(f"write data at {path!r}", status)
 
     def list_all_occurrences(self, ids_name: str) -> List[int]:
         """List all occurrences of this IDS."""
@@ -174,6 +174,17 @@ class ALContext:
             return list(occurrences)
         return []
 
+    def list_filled_paths(self, path: str) -> List[str]:
+        """List all filled paths in an IDS.
+
+        Args:
+            path: IDS and occurrence as a string: <IDS>[/<occurrence>]
+        """
+        status, result = ll_interface.list_filled_paths(self.ctx, path)
+        if status != 0:
+            raise LowlevelError(f"list filled paths for {path!r}", status)
+        return result
+
     def close(self):
         """Close this ALContext."""
         ll_interface.end_action(self.ctx)
@@ -359,7 +370,7 @@ class LazyALContext:
         tmin: float,
         tmax: float,
         dtime: Optional[numpy.ndarray],
-        interpolation_method: int,
+        interpolation_method: Optional[int],
     ) -> Iterator["LazyALContext"]:
         """Lazily start a lowlevel timerange action, see
         :meth:`ALContext.timerange_action`.

imas/backends/imas_core/db_entry_al.py

@@ -38,8 +38,8 @@ from imas.ids_toplevel import IDSToplevel
 
 from .al_context import ALContext, LazyALContext
 from .db_entry_helpers import delete_children, get_children, put_children
-from .imas_interface import LLInterfaceError, has_imas, ll_interface
-from .mdsplus_model import mdsplus_model_dir
+from .imas_interface import LLInterfaceError, ll_interface
+from .mdsplus_model import mdsplus_model_dir, get_mdsplus_model_var
 from .uda_support import extract_idsdef, get_dd_version_from_idsdef_xml
 
 _OPEN_MODES = {
@@ -52,14 +52,6 @@ _OPEN_MODES = {
 logger = logging.getLogger(__name__)
 
 
-def require_imas_available():
-    if not has_imas:
-        raise RuntimeError(
-            "The IMAS Core library is not available. Please install 'imas_core', "
-            "or load a supported IMAS module if you use an HPC environment."
-        )
-
-
 class ALDBEntryImpl(DBEntryImpl):
     """DBEntry implementation using imas_core as a backend."""
 
@@ -86,7 +78,6 @@ class ALDBEntryImpl(DBEntryImpl):
 
     @classmethod
     def from_uri(cls, uri: str, mode: str, factory: IDSFactory) -> "ALDBEntryImpl":
-        require_imas_available()
         if mode not in _OPEN_MODES:
             modes = list(_OPEN_MODES)
             raise ValueError(f"Unknown mode {mode!r}, was expecting any of {modes}")
@@ -105,9 +96,6 @@ class ALDBEntryImpl(DBEntryImpl):
         options: Any,
         factory: IDSFactory,
     ) -> "ALDBEntryImpl":
-        # Raise an error if imas is not available
-        require_imas_available()
-
         # Set defaults
         user_name = user_name or getpass.getuser()
         data_version = data_version or factory.dd_version
@@ -131,7 +119,7 @@ class ALDBEntryImpl(DBEntryImpl):
                 # Building the MDS+ models is required when creating a new Data Entry
                 ids_path = mdsplus_model_dir(factory)
                 if ids_path:
-                    os.environ["ids_path"] = ids_path
+                    os.environ[get_mdsplus_model_var()] = ids_path
 
         elif backend == "uda":
             # Set IDSDEF_PATH to point the UDA backend to the selected DD version
@@ -149,7 +137,7 @@ class ALDBEntryImpl(DBEntryImpl):
             if idsdef_path is None:
                 # Extract XML from the DD zip and point UDA to it
                 idsdef_path = extract_idsdef(factory.version)
-            os.environ["IDSDEF_PATH"] = idsdef_path
+            os.environ["IDSDEF_PATH"] = str(idsdef_path)
 
         elif backend in ["hdf5", "memory", "ascii", "flexbuffers"]:
             pass  # nothing to set up
@@ -184,7 +172,7 @@ class ALDBEntryImpl(DBEntryImpl):
         destination: IDSToplevel,
         lazy: bool,
         nbc_map: Optional[NBCPathMap],
-    ) -> None:
+    ) -> IDSToplevel:
         if self._db_ctx is None:
             raise RuntimeError("Database entry is not open.")
         if lazy and self.backend == "ascii":
@@ -268,6 +256,22 @@ class ALDBEntryImpl(DBEntryImpl):
             raise DataEntryException(
                 f"IDS {ids_name!r}, occurrence {occurrence} is empty."
             )
+
+        # UDA caching doesn't play well when the DD version of the on-disk IDS doesn't
+        # match the DD version of this DBEntry. See GH#97
+        if self.backend == "uda" and dd_version != self._ids_factory.dd_version:
+            cache_mode = self._querydict.get("cache_mode")
+            fetch = self._querydict.get("fetch")
+            if cache_mode != "none" and fetch not in ("1", "true"):
+                raise RuntimeError(
+                    f"The Data Dictionary version of the data ({dd_version}) is "
+                    "different from the Data Dictionary version of the DBEntry "
+                    f"({self._ids_factory.dd_version}). This is not supported when "
+                    f"using the UDA backend. See {imas.PUBLISHED_DOCUMENTATION_ROOT}"
+                    "multi-dd.html#uda-backend-caching-and-data-dictionary-versions "
+                    "for more details and workarounds."
+                )
+
         return dd_version
 
     def put(self, ids: IDSToplevel, occurrence: int, is_slice: bool) -> None:
@@ -299,7 +303,7 @@ class ALDBEntryImpl(DBEntryImpl):
         if occurrence != 0:
             ll_path += f"/{occurrence}"
 
-        time_mode = ids.ids_properties.homogeneous_time
+        time_mode = int(ids.ids_properties.homogeneous_time)
         if is_slice:
             with self._db_ctx.global_action(ll_path, READ_OP) as read_ctx:
                 db_time_mode = read_ctx.read_data(
@@ -344,9 +348,12 @@ class ALDBEntryImpl(DBEntryImpl):
             ll_path += f"/{occurrence}"
         ids = self._ids_factory.new(ids_name)
         with self._db_ctx.global_action(ll_path, WRITE_OP) as write_ctx:
-            delete_children(ids.metadata, write_ctx, "")
+            delete_children(ids.metadata, write_ctx)
 
     def list_all_occurrences(self, ids_name: str) -> List[int]:
+        if self._db_ctx is None:
+            raise RuntimeError("Database entry is not open.")
+
         try:
             occurrence_list = self._db_ctx.list_all_occurrences(ids_name)
         except LLInterfaceError:
@@ -357,6 +364,19 @@ class ALDBEntryImpl(DBEntryImpl):
             ) from None
         return occurrence_list
 
+    def list_filled_paths(self, ids_name: str, occurrence: int) -> List[str]:
+        if self._db_ctx is None:
+            raise RuntimeError("Database entry is not open.")
+        ll_path = ids_name
+        if occurrence != 0:
+            ll_path += f"/{occurrence}"
+        paths = self._db_ctx.list_filled_paths(ll_path)
+        if not paths:
+            raise DataEntryException(
+                f"IDS {ids_name!r}, occurrence {occurrence} is empty."
+            )
+        return paths
+
     def _check_uda_warnings(self, lazy: bool) -> None:
         """Various checks / warnings for the UDA backend."""
         cache_mode = self._querydict.get("cache_mode")

imas/backends/imas_core/imas_interface.py

@@ -12,30 +12,17 @@ import logging
 
 from packaging.version import Version
 
-logger = logging.getLogger(__name__)
+# Import the Access Layer module
+# First try to import imas_core, which is available since AL 5.2
+from imas_core import _al_lowlevel as lowlevel
+from imas_core import imasdef  # noqa: F401
 
+logger = logging.getLogger(__name__)
 
-# Import the Access Layer module
-has_imas = True
-try:
-    # First try to import imas_core, which is available since AL 5.2
-    from imas_core import _al_lowlevel as lowlevel
-    from imas_core import imasdef
-
-    # Enable throwing exceptions from the _al_lowlevel interface
-    enable_exceptions = getattr(lowlevel, "imas_core_config_enable_exceptions", None)
-    if enable_exceptions:
-        enable_exceptions()
-
-except ImportError as exc:
-    imas = None
-    has_imas = False
-    imasdef = None
-    lowlevel = None
-    logger.warning(
-        "Could not import 'imas_core': %s. Some functionality is not available.",
-        exc,
-    )
+# Enable throwing exceptions from the _al_lowlevel interface
+enable_exceptions = getattr(lowlevel, "imas_core_config_enable_exceptions", None)
+if enable_exceptions:
+    enable_exceptions()
 
 
 class LLInterfaceError(RuntimeError):
@@ -179,6 +166,11 @@ class LowlevelInterface:
     ):
         raise self._minimal_version("5.4")
 
+    # New method in AL 5.7
+
+    def list_filled_paths(self, ctx, path):
+        raise self._minimal_version("5.7")
+
 
 # Dummy documentation for interface:
 for funcname in dir(LowlevelInterface):

imas/backends/imas_core/mdsplus_model.py

@@ -14,6 +14,7 @@ import uuid
 from pathlib import Path
 from subprocess import CalledProcessError, check_output
 from zlib import crc32
+from packaging.version import Version
 
 try:
     from importlib.resources import as_file, files
@@ -24,6 +25,8 @@ from imas.dd_zip import get_dd_xml, get_dd_xml_crc
 from imas.exception import MDSPlusModelError
 from imas.ids_factory import IDSFactory
 
+from .imas_interface import ll_interface
+
 logger = logging.getLogger(__name__)
 
 
@@ -292,6 +295,20 @@ def create_model_ids_xml(cache_dir_path, fname, version):
         raise e
 
 
+def get_mdsplus_model_var() -> str:
+    """
+    Return the environemnt variable name used by IMAS-Core to locate models:
+
+    - 'ids_path' for IMAS-Core<5.6
+    - 'MDSPLUS_MODELS_PATH' for IMAS-Core>=5.6
+    """
+    return (
+        "ids_path"
+        if ll_interface._al_version < Version("5.6.0")
+        else "MDSPLUS_MODELS_PATH"
+    )
+
+
 def create_mdsplus_model(cache_dir_path: Path) -> None:
     """Use jtraverser to compile a valid MDS model file."""
     try:
@@ -322,7 +339,7 @@ def create_mdsplus_model(cache_dir_path: Path) -> None:
             env={
                 "PATH": os.environ.get("PATH", ""),
                 "LD_LIBRARY_PATH": os.environ.get("LD_LIBRARY_PATH", ""),
-                "ids_path": str(cache_dir_path),
+                get_mdsplus_model_var(): str(cache_dir_path),
             },
         )
         # Touch a file to show that we have finished the model
@@ -349,7 +366,7 @@ def jTraverser_jar() -> Path:
     for component in os.environ.get("CLASSPATH", "").split(":"):
         if component.endswith(".jar"):
             if re.search(".*jTraverser.jar", component):
-                return component
+                return Path(component)
         else:  # assume its a directory (strip any '*' suffix)
             search_dirs.append(component.rstrip("*"))
 

imas/backends/imas_core/uda_support.py

@@ -1,6 +1,6 @@
 import logging
 from pathlib import Path
-from typing import Union
+from typing import Union, Optional
 from xml.etree import ElementTree as ET
 
 from imas import dd_zip
@@ -10,7 +10,7 @@ from .mdsplus_model import _get_xdg_cache_dir
 logger = logging.getLogger(__name__)
 
 
-def get_dd_version_from_idsdef_xml(path: Union[str, Path]) -> str:
+def get_dd_version_from_idsdef_xml(path: Union[str, Path]) -> Optional[str]:
     """Parse the IDSDef.xml up to the point where the Data Dictionary version is set.
 
     Returns:

imas/backends/netcdf/db_entry_nc.py

@@ -92,6 +92,14 @@ class NCDBEntryImpl(DBEntryImpl):
             )
         self._dataset.close()
 
+    def _get_group(self, ids_name: str, occurrence: int) -> "netCDF4.Group":
+        try:
+            return self._dataset[f"{ids_name}/{occurrence}"]
+        except LookupError as exc:
+            raise DataEntryException(
+                f"IDS {ids_name!r}, occurrence {occurrence} is not found."
+            ) from exc
+
     def get(
         self,
         ids_name: str,
@@ -100,7 +108,7 @@ class NCDBEntryImpl(DBEntryImpl):
         destination: IDSToplevel,
         lazy: bool,
         nbc_map: Optional[NBCPathMap],
-    ) -> None:
+    ) -> IDSToplevel:
         # Feature compatibility checks
         if parameters is not None:
             if isinstance(parameters, GetSliceParameters):
@@ -110,12 +118,7 @@ class NCDBEntryImpl(DBEntryImpl):
             raise NotImplementedError(f"`{func}` is not available for netCDF files.")
 
         # Check if the IDS/occurrence exists, and obtain the group it is stored in
-        try:
-            group = self._dataset[f"{ids_name}/{occurrence}"]
-        except KeyError:
-            raise DataEntryException(
-                f"IDS {ids_name!r}, occurrence {occurrence} is not found."
-            )
+        group = self._get_group(ids_name, occurrence)
 
         # Load data into the destination IDS
         if self._ds_factory.dd_version == destination._dd_version:
@@ -183,3 +186,17 @@ class NCDBEntryImpl(DBEntryImpl):
 
         occurrence_list.sort()
         return occurrence_list
+
+    def list_filled_paths(self, ids_name: str, occurrence: int) -> List[str]:
+        # Check if the IDS/occurrence exists, and obtain the group it is stored in
+        group = self._get_group(ids_name, occurrence)
+
+        result = []
+        for name, variable in group.variables.items():
+            if variable.ndim == 0 and variable.dtype == "S1":
+                continue  # (Array of) Structure metadata node, no data
+            if name.endswith(":shape"):
+                continue  # Shape data, not a DD path
+            result.append(name.replace(".", "/"))
+
+        return result

imas/backends/netcdf/ids2nc.py

@@ -47,7 +47,6 @@ class IDS2NC(IDSTensorizer):
 
     def create_variables(self) -> None:
         """Create netCDF variables."""
-        get_dimensions = self.ncmeta.get_dimensions
         for path in self.filled_data:
             metadata = self.ids.metadata[path]
             var_name = path.replace("/", ".")
@@ -75,54 +74,21 @@ class IDS2NC(IDSTensorizer):
                 if dtype is not dtypes[IDSDataType.CPX]:  # Set fillvalue
                     kwargs.update(fill_value=default_fillvals[metadata.data_type])
                 # Create variable
-                dimensions = get_dimensions(path, self.homogeneous_time)
+                dimensions = self.get_dimensions(path)
                 var = self.group.createVariable(var_name, dtype, dimensions, **kwargs)
 
             # Fill metadata attributes
-            var.documentation = metadata.documentation
-            if metadata.units:
-                var.units = metadata.units
-
-            ancillary_variables = " ".join(
-                error_var
-                for error_var in [f"{var_name}_error_upper", f"{var_name}_error_lower"]
-                if error_var in self.filled_variables
-            )
-            if ancillary_variables:
-                var.ancillary_variables = ancillary_variables
-
-            if metadata.data_type is not IDSDataType.STRUCT_ARRAY:
-                coordinates = self.filter_coordinates(path)
-                if coordinates:
-                    var.coordinates = coordinates
-
-            # Sparsity and :shape array
-            if path in self.shapes:
-                if not metadata.ndim:
-                    # Doesn't need a :shape array:
-                    var.sparse = "Sparse data, missing data is filled with _FillValue"
-                    var.sparse += f" ({default_fillvals[metadata.data_type]})"
-
-                else:
-                    shape_name = f"{var_name}:shape"
-                    var.sparse = f"Sparse data, data shapes are stored in {shape_name}"
-
-                    # Create variable to store data shape
-                    dimensions = get_dimensions(
-                        self.ncmeta.aos.get(path), self.homogeneous_time
-                    ) + (f"{metadata.ndim}D",)
-                    shape_var = self.group.createVariable(
-                        shape_name,
-                        SHAPE_DTYPE,
-                        dimensions,
-                    )
-                    doc_indices = ",".join(chr(ord("i") + i) for i in range(3))
-                    shape_var.documentation = (
-                        f"Shape information for {var_name}.\n"
-                        f"{shape_name}[{doc_indices},:] describes the shape of filled "
-                        f"data of {var_name}[{doc_indices},...]. Data outside this "
-                        "shape is unset (i.e. filled with _Fillvalue)."
-                    )
+            var.setncatts(self.get_attributes(path, default_fillvals))
+
+            # :shape array for sparse data
+            if path in self.shapes and metadata.ndim:
+                shape_name = f"{var_name}:shape"
+                # Create variable to store data shape
+                dimensions = self.get_shape_dimensions(path)
+                shape_var = self.group.createVariable(
+                    shape_name, SHAPE_DTYPE, dimensions
+                )
+                shape_var.setncatts(self.get_shape_attributes(var_name))
 
     def store_data(self) -> None:
         """Store data in the netCDF variables"""