imas-python 2.2.0__py3-none-any.whl → 2.3.1__py3-none-any.whl

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),
@@ -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.2.0'
-__version_tuple__ = version_tuple = (2, 2, 0)
+__version__ = version = '2.3.1'
+__version_tuple__ = version_tuple = (2, 3, 1)
 
-__commit_id__ = commit_id = None
+__commit_id__ = commit_id = 'gdc78cc36c'

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

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

@@ -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)

imas/backends/imas_core/db_entry_al.py

@@ -364,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

@@ -166,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

@@ -12,7 +12,7 @@ import tempfile
 import time
 import uuid
 from pathlib import Path
-from subprocess import CalledProcessError, check_output
+from subprocess import STDOUT, CalledProcessError, check_output
 from zlib import crc32
 from packaging.version import Version
 
@@ -324,12 +324,19 @@ def create_mdsplus_model(cache_dir_path: Path) -> None:
                 "Could not determine CompileTree class in jTraverser.jar."
             )
         compiletree = compiletree_class.rpartition(".class")[0].replace("/", ".")
+        # only add option to suppress warning if the JVM supports it
+        native_access = ["--enable-native-access=ALL-UNNAMED"]
+        try:
+            check_output(["java", *native_access, "-version"], stderr=STDOUT)
+        except CalledProcessError:
+            native_access = []
         check_output(
             [
                 "java",
                 "-Xms1g",  # what do these do?
                 "-Xmx8g",  # what do these do?
                 "-XX:+UseG1GC",  # what do these do?
+                *native_access,
                 "-cp",
                 jarfile,
                 compiletree,
@@ -339,13 +346,14 @@ def create_mdsplus_model(cache_dir_path: Path) -> None:
             env={
                 "PATH": os.environ.get("PATH", ""),
                 "LD_LIBRARY_PATH": os.environ.get("LD_LIBRARY_PATH", ""),
-                get_mdsplus_model_var(): str(cache_dir_path),
+                # MDSplus locates models through '<tree>_path' (tree='ids')
+                "ids_path": str(cache_dir_path),
             },
         )
         # Touch a file to show that we have finished the model
         (cache_dir_path / "done.txt").touch()
     except CalledProcessError as e:
-        logger.error("Error making MDSPlus model in {path}", cache_dir_path)
+        logger.error("Error making MDSPlus model in %s", cache_dir_path)
         raise e
 
 

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,
@@ -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"""

imas/backends/netcdf/ids_tensorizer.py

@@ -3,7 +3,7 @@
 """Tensorization logic to convert IDSs to netCDF files and/or xarray Datasets."""
 
 from collections import deque
-from typing import List
+from typing import List, Tuple, Dict
 
 import numpy
 
@@ -47,13 +47,26 @@ class IDSTensorizer:
         """Map of IDS paths to filled data nodes."""
         self.filled_variables = set()
         """Set of filled IDS variables"""
-        self.homogeneous_time = (
+        self.homogeneous_time = bool(
             ids.ids_properties.homogeneous_time == IDS_TIME_MODE_HOMOGENEOUS
         )
         """True iff the IDS time mode is homogeneous."""
         self.shapes = {}
         """Map of IDS paths to data shape arrays."""
 
+    def get_dimensions(self, path: str) -> Tuple[str, ...]:
+        """Get the dimensions for a netCDF variable.
+
+        Args:
+            path: Data Dictionary path to the variable, e.g. ``ids_properties/comment``.
+        """
+        return self.ncmeta.get_dimensions(path, self.homogeneous_time)
+
+    def get_shape_dimensions(self, path: str) -> Tuple[str, ...]:
+        """Get dimensions names for shape array of the tensorized variable"""
+        ndim = self.ids.metadata[path].ndim
+        return self.get_dimensions(self.ncmeta.aos.get(path, "")) + (f"{ndim}D",)
+
     def include_coordinate_paths(self) -> None:
         """Append all paths that are coordinates of self.paths_to_tensorize"""
         # Use a queue so we can also take coordinates of coordinates into account
@@ -62,7 +75,7 @@ class IDSTensorizer:
         for path in self.paths_to_tensorize:
             while path:
                 path, _, _ = path.rpartition("/")
-                if self.ncmeta.get_dimensions(path, self.homogeneous_time):
+                if self.get_dimensions(path):
                     queue.append(path)
 
         self.paths_to_tensorize = []
@@ -82,7 +95,6 @@ class IDSTensorizer:
         # Initialize dictionary with all paths that could exist in this IDS
         filled_data = {path: {} for path in self.ncmeta.paths}
         dimension_size = {}
-        get_dimensions = self.ncmeta.get_dimensions
 
         if self.paths_to_tensorize:
             # Restrict tensorization to provided paths
@@ -102,7 +114,7 @@ class IDSTensorizer:
             ndim = node.metadata.ndim
             if not ndim:
                 continue
-            dimensions = get_dimensions(path, self.homogeneous_time)
+            dimensions = self.get_dimensions(path)
             # We're only interested in the non-tensorized dimensions: [-ndim:]
             for dim_name, size in zip(dimensions[-ndim:], node.shape):
                 dimension_size[dim_name] = max(dimension_size.get(dim_name, 0), size)
@@ -115,15 +127,13 @@ class IDSTensorizer:
 
     def determine_data_shapes(self) -> None:
         """Determine tensorized data shapes and sparsity, save in :attr:`shapes`."""
-        get_dimensions = self.ncmeta.get_dimensions
-
         for path, nodes_dict in self.filled_data.items():
             metadata = self.ids.metadata[path]
             # Structures don't have a size
             if metadata.data_type is IDSDataType.STRUCTURE:
                 continue
             ndim = metadata.ndim
-            dimensions = get_dimensions(path, self.homogeneous_time)
+            dimensions = self.get_dimensions(path)
 
             # node shape if it is completely filled
             full_shape = tuple(self.dimension_size[dim] for dim in dimensions[-ndim:])
@@ -137,7 +147,7 @@ class IDSTensorizer:
 
             else:
                 # Data is tensorized, determine if it is homogeneously shaped
-                aos_dims = get_dimensions(self.ncmeta.aos[path], self.homogeneous_time)
+                aos_dims = self.get_dimensions(self.ncmeta.aos[path])
                 shapes_shape = [self.dimension_size[dim] for dim in aos_dims]
                 if ndim:
                     shapes_shape.append(ndim)
@@ -168,6 +178,55 @@ class IDSTensorizer:
             if coordinate in self.filled_variables
         )
 
+    def get_attributes(self, path: str, fillvals: dict) -> Dict[str, str]:
+        """Get metadata attributes of the tensorized variable"""
+        metadata = self.ids.metadata[path]
+        var_name = path.replace("/", ".")
+
+        assert metadata.documentation is not None
+        attrs = {"documentation": metadata.documentation}
+        if metadata.units:
+            attrs["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:
+            attrs["ancillary_variables"] = ancillary_variables
+
+        if metadata.data_type is not IDSDataType.STRUCT_ARRAY:
+            coordinates = self.filter_coordinates(path)
+            if coordinates:
+                attrs["coordinates"] = coordinates
+
+        # Sparsity
+        if path in self.shapes:
+            if not metadata.ndim:
+                # Doesn't need a :shape array
+                attrs["sparse"] = (
+                    "Sparse data, missing data is filled with _FillValue"
+                    f" ({fillvals[metadata.data_type]})"
+                )
+            else:
+                attrs["sparse"] = (
+                    f"Sparse data, data shapes are stored in {var_name}:shape"
+                )
+
+        return attrs
+
+    def get_shape_attributes(self, var_name: str) -> Dict[str, str]:
+        """Get attributes of the :shape variable corresponding to var_name"""
+        doc_indices = ",".join(chr(ord("i") + i) for i in range(3))
+        documentation = (
+            f"Shape information for {var_name}.\n"
+            f"{var_name}:shape[{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)."
+        )
+        return {"documentation": documentation}
+
     def tensorize(self, path, fillvalue):
         """
         Tensorizes the data at the given path with the specified fill value.
@@ -180,7 +239,7 @@ class IDSTensorizer:
         Returns:
             A tensor filled with the data from the specified path.
         """
-        dimensions = self.ncmeta.get_dimensions(path, self.homogeneous_time)
+        dimensions = self.get_dimensions(path)
         shape = tuple(self.dimension_size[dim] for dim in dimensions)
 
         # TODO: depending on the data, tmp_var may be HUGE, we may need a more

imas/backends/netcdf/nc2ids.py

@@ -1,6 +1,6 @@
 import logging
 import os
-from typing import Optional
+from typing import Optional, Tuple
 
 import netCDF4
 import numpy as np
@@ -80,6 +80,14 @@ class NC2IDS:
             )
         self.homogeneous_time = var[()] == IDS_TIME_MODE_HOMOGENEOUS
 
+    def get_dimensions(self, path: str) -> Tuple[str, ...]:
+        """Get the dimensions for a netCDF variable.
+
+        Args:
+            path: Data Dictionary path to the variable, e.g. ``ids_properties/comment``.
+        """
+        return self.ncmeta.get_dimensions(path, self.homogeneous_time)
+
     def run(self, lazy: bool) -> None:
         """Load the data from the netCDF group into the IDS."""
         self.variables.sort()
@@ -130,9 +138,7 @@ class NC2IDS:
 
                 else:
                     # FIXME: extract dimension name from nc file?
-                    dim = self.ncmeta.get_dimensions(
-                        metadata.path_string, self.homogeneous_time
-                    )[-1]
+                    dim = self.get_dimensions(metadata.path_string)[-1]
                     size = self.group.dimensions[dim].size
                     for _, node in indexed_tree_iter(self.ids, target_metadata):
                         node.resize(size)
@@ -235,9 +241,7 @@ class NC2IDS:
                 raise variable_error(var, "data type", var.dtype, expected_dtype)
 
             # Dimensions
-            expected_dims = self.ncmeta.get_dimensions(
-                metadata.path_string, self.homogeneous_time
-            )
+            expected_dims = self.get_dimensions(metadata.path_string)
             if var.dimensions != expected_dims:
                 raise variable_error(var, "dimensions", var.dimensions, expected_dims)
 
@@ -298,9 +302,7 @@ class NC2IDS:
             return  # Sparsity is stored with _Fillvalue, nothing to validate
 
         # Dimensions
-        aos_dimensions = self.ncmeta.get_dimensions(
-            self.ncmeta.aos.get(metadata.path_string), self.homogeneous_time
-        )
+        aos_dimensions = self.get_dimensions(self.ncmeta.aos.get(metadata.path_string))
         shape_dimensions = shape_var.dimensions
         if (
             len(shape_dimensions) != len(aos_dimensions) + 1
@@ -331,7 +333,6 @@ class LazyContext:
 
         Args:
             child: The child IDS node which should be lazy loaded.
-
         """
         metadata = child.metadata
         path = metadata.path_string
@@ -347,9 +348,7 @@ class LazyContext:
                 size = nc2ids.group[var.name + ":shape"][self.index][0]
             else:
                 # FIXME: extract dimension name from nc file?
-                dim = nc2ids.ncmeta.get_dimensions(
-                    metadata.path_string, nc2ids.homogeneous_time
-                )[-1]
+                dim = nc2ids.get_dimensions(metadata.path_string)[-1]
                 size = nc2ids.group.dimensions[dim].size
 
             child._set_lazy_context(LazyArrayStructContext(nc2ids, self.index, size))

imas/db_entry.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 import logging
 import os
 import pathlib
-from typing import Any, Type, overload
+from typing import Any, Type, overload, List
 
 import numpy
 
@@ -113,7 +113,10 @@ class DBEntry:
             object before you can use it for reading or writing data.
 
         Args:
-            uri: URI to the data entry, see explanation above.
+            uri: URI to the data entry (a path to a netCDF file ending with .nc,
+                or an `IMAS URI for one of IMAS-Core's backends
+                <https://imas-core.readthedocs.io/en/latest/user_guide/uris_guide.html>`__
+                ).
             mode: Mode to open the Data Entry in:
 
               - ``"r"``: Open an existing data entry. Raises an error when the data
@@ -197,14 +200,14 @@ class DBEntry:
             from imas.backends.imas_core.db_entry_al import ALDBEntryImpl as impl
         return impl
 
-    def __enter__(self):
+    def __enter__(self) -> "DBEntry":
         # Context manager protocol
         if self._dbe_impl is None:
             # Open if the DBEntry was not already opened or created
             self.open()
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
         # Context manager protocol
         self.close()
 
@@ -800,3 +803,63 @@ class DBEntry:
             self.get(ids_name, occ, lazy=True)[node_path] for occ in occurrence_list
         ]
         return occurrence_list, node_content_list
+
+    def list_filled_paths(
+        self, ids_name, occurrence: int = 0, *, autoconvert: bool = True
+    ) -> List[str]:
+        """Get a list of filled Data Dictionary paths from the backend.
+
+        Note that this is only supported by some backends (HDF5 and netCDF), and will
+        result in an error on unsupported backends.
+
+        Args:
+            ids_name: Name of the IDS to request filled data for.
+            occurrence: Occurrence number of the IDS to request filled data for.
+
+        Keyword Args:
+            autoconvert: If enabled (default), this method will take NBC renames into
+                account in the returned list of filled paths. This argument corresponds
+                to the :py:data:`~get.autoconvert` argument of :py:meth:`get`.
+
+        Returns:
+            List of paths which have some data filled in the backend. For example, when
+            ``profiles_1d/ion/temperature`` is in this list, it means that there is at
+            least one ``ion`` in one ``profiles_1d`` entry for which the temperature is
+            filled.
+
+            The paths in this list may be ordered arbitrarily.
+
+        Example:
+            >>> with imas.DBEntry("imas:hdf5?path=./path/to/data", "r") as entry:
+            >>>     print(entry.list_filled_paths("core_profiles"))
+            ['ids_properties/comment', 'ids_properties/homogeneous_time',
+             'profiles_1d/grid/rho_tor_norm', 'profiles_1d/electrons/temperature',
+             'profiles_1d/ion/temperature', 'time']
+        """
+        if self._dbe_impl is None:
+            raise RuntimeError("Database entry is not open.")
+        paths = self._dbe_impl.list_filled_paths(ids_name, occurrence)
+        if not autoconvert:
+            return paths
+
+        # DD conversion?
+        dd_version = self._dbe_impl.read_dd_version(ids_name, occurrence)
+        if dd_version == self._ids_factory.dd_version:
+            return paths  # No conversion required
+
+        # Follow any NBC renames:
+        ddmap, source_is_older = dd_version_map_from_factories(
+            ids_name, IDSFactory(version=dd_version), self._ids_factory
+        )
+        nbc_map = ddmap.old_to_new if source_is_older else ddmap.new_to_old
+
+        converted_paths = []
+        for path in paths:
+            if path in nbc_map:
+                new_name = nbc_map.path[path]
+                if new_name is not None:
+                    converted_paths.append(new_name)
+            else:
+                converted_paths.append(path)
+
+        return converted_paths