imas-python 1.2.1.dev13__py3-none-any.whl → 2.0.0__py3-none-any.whl

imas/ids_structure.py

@@ -6,11 +6,10 @@
 import logging
 from copy import deepcopy
 from types import MappingProxyType
-from typing import Generator, List, Optional, Union
+from typing import TYPE_CHECKING, Generator, List, Optional, Union
 
 from xxhash import xxh3_64
 
-from imas.backends.imas_core.al_context import LazyALContext
 from imas.ids_base import IDSBase, IDSDoc
 from imas.ids_identifiers import IDSIdentifier
 from imas.ids_metadata import IDSDataType, IDSMetadata
@@ -18,6 +17,9 @@ from imas.ids_path import IDSPath
 from imas.ids_primitive import IDSPrimitive
 from imas.ids_struct_array import IDSStructArray
 
+if TYPE_CHECKING:
+    from imas.backends.imas_core.al_context import LazyALContext
+
 logger = logging.getLogger(__name__)
 
 
@@ -32,7 +34,7 @@ class IDSStructure(IDSBase):
 
     __doc__ = IDSDoc(__doc__)
     _children: "MappingProxyType[str, IDSMetadata]"
-    _lazy_context: Optional[LazyALContext]
+    _lazy_context: Optional["LazyALContext"]
 
     def __init__(self, parent: IDSBase, metadata: IDSMetadata):
         """Initialize IDSStructure from metadata specification
@@ -62,10 +64,8 @@ class IDSStructure(IDSBase):
         child_meta = self._children[name]
         child = child_meta._node_type(self, child_meta)
         self.__dict__[name] = child  # bypass setattr logic below: avoid recursion
-        if self._lazy:  # lazy load the child
-            from imas.backends.imas_core.db_entry_helpers import _get_child
-
-            _get_child(child, self._lazy_context)
+        if self._lazy and self._lazy_context is not None:  # lazy load the child
+            self._lazy_context.get_child(child)
         return child
 
     def _assign_identifier(self, value: Union[IDSIdentifier, str, int]) -> None:
@@ -168,7 +168,7 @@ class IDSStructure(IDSBase):
             return False  # Not equal if there is any difference
         return True  # Equal when there are no differences
 
-    def _set_lazy_context(self, ctx: LazyALContext) -> None:
+    def _set_lazy_context(self, ctx: "LazyALContext") -> None:
         """Called by DBEntry during a lazy get/get_slice.
 
         Set the context that we can use for retrieving our children.

imas/test/test_ids_convert.py

@@ -200,7 +200,8 @@ def test_provenance_entry(factory):
     timestamp = str(cp4.ids_properties.provenance.node[0].reference[0].timestamp)
     # Check that timestamp adheres to the format YYYY-MM-DDTHH:MM:SSZ
     assert re.match(r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z", timestamp)
-    dtime = datetime.now(UTC) - datetime.fromisoformat(timestamp)
+    timestamp_for_parsing = timestamp.replace("Z", "+00:00")
+    dtime = datetime.now(UTC) - datetime.fromisoformat(timestamp_for_parsing)
     assert timedelta(seconds=0) <= dtime < timedelta(seconds=2)
 
 

imas/test/test_lazy_loading.py

@@ -3,7 +3,6 @@ from unittest.mock import DEFAULT, patch
 
 import numpy
 import pytest
-
 from imas.backends.imas_core.imas_interface import ll_interface
 from imas.db_entry import DBEntry
 from imas.ids_defs import (
@@ -22,6 +21,15 @@ def test_lazy_load_aos(backend, worker_id, tmp_path, log_lowlevel_calls):
     if backend == ASCII_BACKEND:
         pytest.skip("Lazy loading is not supported by the ASCII backend.")
     dbentry = open_dbentry(backend, "w", worker_id, tmp_path, dd_version="3.39.0")
+    run_lazy_load_aos(dbentry)
+
+
+def test_lazy_load_aos_netcdf(tmp_path):
+    dbentry = DBEntry(str(tmp_path / "lazy_load_aos.nc"), "x", dd_version="3.39.0")
+    run_lazy_load_aos(dbentry)
+
+
+def run_lazy_load_aos(dbentry):
     ids = dbentry.factory.new("core_profiles")
     ids.ids_properties.homogeneous_time = IDS_TIME_MODE_HETEROGENEOUS
     ids.profiles_1d.resize(10)
@@ -46,9 +54,12 @@ def test_lazy_load_aos(backend, worker_id, tmp_path, log_lowlevel_calls):
             assert values[method].call_count == 0
 
     # Test get_slice
-    lazy_ids_slice = dbentry.get_slice("core_profiles", 3.5, PREVIOUS_INTERP, lazy=True)
-    assert lazy_ids_slice.profiles_1d.shape == (1,)
-    assert lazy_ids_slice.profiles_1d[0].time == 3
+    try:
+        lazy_slice = dbentry.get_slice("core_profiles", 3.5, PREVIOUS_INTERP, lazy=True)
+        assert lazy_slice.profiles_1d.shape == (1,)
+        assert lazy_slice.profiles_1d[0].time == 3
+    except NotImplementedError:
+        pass  # netCDF backend doesn't implement get_slice
 
     dbentry.close()
 
@@ -57,6 +68,15 @@ def test_lazy_loading_distributions_random(backend, worker_id, tmp_path):
     if backend == ASCII_BACKEND:
         pytest.skip("Lazy loading is not supported by the ASCII backend.")
     dbentry = open_dbentry(backend, "w", worker_id, tmp_path)
+    run_lazy_loading_distributions_random(dbentry)
+
+
+def test_lazy_loading_distributions_random_netcdf(tmp_path):
+    dbentry = DBEntry(str(tmp_path / "lazy_load_distributions.nc"), "x")
+    run_lazy_loading_distributions_random(dbentry)
+
+
+def run_lazy_loading_distributions_random(dbentry):
     ids = IDSFactory().new("distributions")
     fill_consistent(ids)
     dbentry.put(ids)
@@ -92,7 +112,15 @@ def test_lazy_load_close_dbentry(requires_imas):
 def test_lazy_load_readonly(requires_imas):
     dbentry = DBEntry(MEMORY_BACKEND, "ITER", 1, 1)
     dbentry.create()
+    run_lazy_load_readonly(dbentry)
+
+
+def test_lazy_load_readonly_netcdf(tmp_path):
+    dbentry = DBEntry(str(tmp_path / "lazy_load_readonly.nc"), "x")
+    run_lazy_load_readonly(dbentry)
 
+
+def run_lazy_load_readonly(dbentry):
     ids = dbentry.factory.core_profiles()
     ids.ids_properties.homogeneous_time = IDS_TIME_MODE_HETEROGENEOUS
     ids.time = [1, 2]
@@ -165,6 +193,27 @@ def test_lazy_load_with_new_aos(requires_imas):
     dbentry.close()
 
 
+def test_lazy_load_with_new_aos_netcdf(tmp_path):
+    fname = str(tmp_path / "new_aos.nc")
+    with DBEntry(fname, "x", dd_version="3.30.0") as dbentry:
+        et = dbentry.factory.edge_transport()
+
+        et.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+        et.time = [1.0]
+        et.model.resize(1)
+        et.model[0].ggd.resize(1)
+        et.model[0].ggd[0].electrons.particles.d.resize(1)
+        et.model[0].ggd[0].electrons.particles.d[0].grid_index = -1
+        dbentry.put(et)
+
+    with DBEntry(fname, "r", dd_version="3.39.0") as entry2:
+        lazy_et = entry2.get("edge_transport", lazy=True)
+        assert numpy.array_equal(lazy_et.time, [1.0])
+        assert lazy_et.model[0].ggd[0].electrons.particles.d[0].grid_index == -1
+        # d_radial did not exist in 3.30.0
+        assert len(lazy_et.model[0].ggd[0].electrons.particles.d_radial) == 0
+
+
 def test_lazy_load_with_new_structure(requires_imas):
     dbentry = DBEntry(MEMORY_BACKEND, "ITER", 1, 1, dd_version="3.30.0")
     dbentry.create()

imas/test/test_nbc_change.py

@@ -9,16 +9,11 @@ import logging
 
 import numpy as np
 import pytest
-
 from imas.db_entry import DBEntry
 from imas.ids_convert import convert_ids
 from imas.ids_defs import IDS_TIME_MODE_HOMOGENEOUS, MEMORY_BACKEND
 from imas.ids_factory import IDSFactory
-from imas.test.test_helpers import (
-    compare_children,
-    fill_with_random_data,
-    open_dbentry,
-)
+from imas.test.test_helpers import compare_children, fill_with_random_data, open_dbentry
 
 
 @pytest.fixture(autouse=True)
@@ -97,6 +92,23 @@ def test_nbc_0d_to_1d(caplog, requires_imas):
     entry_339.close()
 
 
+def test_nbc_0d_to_1d_netcdf(caplog, tmp_path):
+    # channel/filter_spectrometer/radiance_calibration in spectrometer visible changed
+    # from FLT_0D to FLT_1D in DD 3.39.0
+    ids = IDSFactory("3.32.0").spectrometer_visible()
+    ids.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    ids.channel.resize(1)
+    ids.channel[0].filter_spectrometer.radiance_calibration = 1.0
+
+    # Test implicit conversion during get
+    with DBEntry(str(tmp_path / "test.nc"), "x", dd_version="3.32.0") as entry_332:
+        entry_332.put(ids)
+    with DBEntry(str(tmp_path / "test.nc"), "r", dd_version="3.39.0") as entry_339:
+        ids_339 = entry_339.get("spectrometer_visible")  # implicit conversion
+        assert not ids_339.channel[0].filter_spectrometer.radiance_calibration.has_value
+        entry_339.close()
+
+
 def test_nbc_change_aos_renamed():
     """Test renamed AoS in pulse_schedule: ec/antenna -> ec/launcher.
 
@@ -272,7 +284,7 @@ def test_pulse_schedule_aos_renamed_autofill_up(backend, worker_id, tmp_path):
     dbentry.close()
 
 
-def test_pulse_schedule_multi_rename():
+def test_pulse_schedule_multi_rename(tmp_path):
     # Multiple renames of the same element:
     # DD >= 3.40+:  ec/beam
     # DD 3.26-3.40: ec/launcher (but NBC metadata added in 3.28 only)
@@ -294,9 +306,18 @@ def test_pulse_schedule_multi_rename():
     ps["3.40.0"].ec.beam[0].name = name
 
     for version1 in ps:
+        ncfilename = str(tmp_path / f"{version1}.nc")
+        with DBEntry(ncfilename, "x", dd_version=version1) as entry:
+            entry.put(ps[version1])
+
         for version2 in ps:
             converted = convert_ids(ps[version1], version2)
-            compare_children(ps[version2], converted)
+            compare_children(ps[version2].ec, converted.ec)
+
+            # Test with netCDF backend
+            with DBEntry(ncfilename, "r", dd_version=version2) as entry:
+                converted = entry.get("pulse_schedule")
+            compare_children(ps[version2].ec, converted.ec)
 
 
 def test_autofill_save_newer(ids_name, backend, worker_id, tmp_path):

imas/test/test_nc_validation.py

@@ -1,7 +1,6 @@
 import netCDF4
 import numpy as np
 import pytest
-
 from imas.backends.netcdf.ids2nc import IDS2NC
 from imas.backends.netcdf.nc2ids import NC2IDS
 from imas.backends.netcdf.nc_validate import validate_netcdf_file
@@ -32,7 +31,8 @@ def memfile_with_ids(memfile, factory):
     ids.profiles_1d[0].zeff = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
     IDS2NC(ids, memfile).run()
     # This one is valid:
-    NC2IDS(memfile, factory.core_profiles()).run()
+    ids = factory.core_profiles()
+    NC2IDS(memfile, ids, ids.metadata, None).run(lazy=False)
     return memfile
 
 
@@ -51,66 +51,75 @@ def test_invalid_homogeneous_time(memfile, factory):
 
     ids = factory.core_profiles()
     with pytest.raises(InvalidNetCDFEntry):
-        NC2IDS(empty_group, ids)  # ids_properties.homogeneous_time does not exist
+        # ids_properties.homogeneous_time does not exist
+        NC2IDS(empty_group, ids, ids.metadata, None)
     with pytest.raises(InvalidNetCDFEntry):
-        NC2IDS(invalid_dtype, ids)
+        NC2IDS(invalid_dtype, ids, ids.metadata, None)
     with pytest.raises(InvalidNetCDFEntry):
-        NC2IDS(invalid_shape, ids)
+        NC2IDS(invalid_shape, ids, ids.metadata, None)
     with pytest.raises(InvalidNetCDFEntry):
-        NC2IDS(invalid_value, ids)
+        NC2IDS(invalid_value, ids, ids.metadata, None)
 
 
 def test_invalid_units(memfile_with_ids, factory):
     memfile_with_ids["time"].units = "hours"
+    ids = factory.core_profiles()
     with pytest.raises(InvalidNetCDFEntry):
-        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+        NC2IDS(memfile_with_ids, ids, ids.metadata, None).run(lazy=False)
 
 
 def test_invalid_documentation(memfile_with_ids, factory, caplog):
+    ids = factory.core_profiles()
     with caplog.at_level("WARNING"):
-        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+        NC2IDS(memfile_with_ids, ids, ids.metadata, None).run(lazy=False)
     assert not caplog.records
     # Invalid docstring logs a warning
     memfile_with_ids["time"].documentation = "https://en.wikipedia.org/wiki/Time"
     with caplog.at_level("WARNING"):
-        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+        NC2IDS(memfile_with_ids, ids, ids.metadata, None).run(lazy=False)
     assert len(caplog.records) == 1
 
 
 def test_invalid_dimension_name(memfile_with_ids, factory):
     memfile_with_ids.renameDimension("time", "T")
+    ids = factory.core_profiles()
     with pytest.raises(InvalidNetCDFEntry):
-        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+        NC2IDS(memfile_with_ids, ids, ids.metadata, None).run(lazy=False)
 
 
 def test_invalid_coordinates(memfile_with_ids, factory):
     memfile_with_ids["profiles_1d.grid.rho_tor_norm"].coordinates = "xyz"
+    ids = factory.core_profiles()
     with pytest.raises(InvalidNetCDFEntry):
-        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+        NC2IDS(memfile_with_ids, ids, ids.metadata, None).run(lazy=False)
 
 
 def test_invalid_ancillary_variables(memfile_with_ids, factory):
     memfile_with_ids["time"].ancillary_variables = "xyz"
+    ids = factory.core_profiles()
     with pytest.raises(InvalidNetCDFEntry):
-        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+        NC2IDS(memfile_with_ids, ids, ids.metadata, None).run(lazy=False)
 
 
 def test_extra_attributes(memfile_with_ids, factory):
     memfile_with_ids["time"].new_attribute = [1, 2, 3]
+    ids = factory.core_profiles()
     with pytest.raises(InvalidNetCDFEntry):
-        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+        NC2IDS(memfile_with_ids, ids, ids.metadata, None).run(lazy=False)
 
 
 def test_shape_array_without_data(memfile_with_ids, factory):
     memfile_with_ids.createVariable("profiles_1d.t_i_average:shape", int, ())
+    ids = factory.core_profiles()
     with pytest.raises(InvalidNetCDFEntry):
-        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+        NC2IDS(memfile_with_ids, ids, ids.metadata, None).run(lazy=False)
 
 
 def test_shape_array_without_sparse_data(memfile_with_ids, factory):
     memfile_with_ids.createVariable("profiles_1d.grid.rho_tor_norm:shape", int, ())
+    ids = factory.core_profiles()
     with pytest.raises(InvalidNetCDFEntry):
-        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+        NC2IDS(memfile_with_ids, ids, ids.metadata, None).run(lazy=False)
 
 
 def test_shape_array_with_invalid_dimensions(memfile_with_ids, factory):
@@ -128,7 +137,7 @@ def test_shape_array_with_invalid_dimensions(memfile_with_ids, factory):
         ("time", "profiles_1d.grid.rho_tor_norm:i"),
     )
     with pytest.raises(InvalidNetCDFEntry):
-        NC2IDS(memfile_with_ids, cp).run()
+        NC2IDS(memfile_with_ids, cp, cp.metadata, None).run(lazy=False)
 
 
 def test_shape_array_with_invalid_dtype(memfile_with_ids, factory):
@@ -144,7 +153,7 @@ def test_shape_array_with_invalid_dtype(memfile_with_ids, factory):
         "profiles_1d.t_i_average:shape", float, ("time", "1D")
     )
     with pytest.raises(InvalidNetCDFEntry):
-        NC2IDS(memfile_with_ids, cp).run()
+        NC2IDS(memfile_with_ids, cp, cp.metadata, None).run(lazy=False)
 
 
 def test_validate_nc(tmpdir):

imas/test/test_to_xarray.py

@@ -0,0 +1,94 @@
+import numpy as np
+import pytest
+
+import imas
+import imas.training
+from imas.util import to_xarray
+
+pytest.importorskip("xarray")
+
+
+@pytest.fixture
+def entry(requires_imas, monkeypatch):
+    monkeypatch.setenv("IMAS_VERSION", "3.39.0")  # Use fixed DD version
+    return imas.training.get_training_db_entry()
+
+
+def test_to_xarray_invalid_argtype():
+    ids = imas.IDSFactory("3.39.0").core_profiles()
+
+    with pytest.raises(TypeError):
+        to_xarray("test")
+    with pytest.raises(TypeError):
+        to_xarray(ids.time)
+    with pytest.raises(TypeError):
+        to_xarray(ids.ids_properties)
+
+
+def test_to_xarray_invalid_paths():
+    ids = imas.IDSFactory("3.39.0").core_profiles()
+
+    with pytest.raises(ValueError, match="xyz"):
+        to_xarray(ids, "xyz")
+    with pytest.raises(ValueError, match="ids_properties/xyz"):
+        to_xarray(ids, "ids_properties/xyz")
+    with pytest.raises(ValueError, match="Xtime"):
+        to_xarray(ids, "time", "Xtime")
+
+
+def validate_trainingdb_electron_temperature_dataset(ds):
+    assert ds.sizes == {"time": 3, "profiles_1d.grid.rho_tor_norm:i": 101}
+    assert ds.data_vars.keys() == {"profiles_1d.electrons.temperature"}
+    assert ds.coords.keys() == {"time", "profiles_1d.grid.rho_tor_norm"}
+
+    # Check that values are loaded as expected
+    assert np.allclose(ds["time"], [3.987222, 432.937598, 792.0])
+    assert np.allclose(
+        ds.isel(time=1)["profiles_1d.electrons.temperature"][10:13],
+        [17728.81703089, 17440.78020568, 17139.35431082],
+    )
+
+
+def test_to_xarray_lazy_loaded(entry):
+    ids = entry.get("core_profiles", lazy=True)
+
+    with pytest.raises(RuntimeError):
+        to_xarray(ids)
+
+    ds = to_xarray(ids, "profiles_1d.electrons.temperature")
+    validate_trainingdb_electron_temperature_dataset(ds)
+
+
+def test_to_xarray_from_trainingdb(entry):
+    ids = entry.get("core_profiles")
+
+    ds = to_xarray(ids)
+    validate_trainingdb_electron_temperature_dataset(
+        ds["profiles_1d.electrons.temperature"].to_dataset()
+    )
+    ds = to_xarray(ids, "profiles_1d.electrons.temperature")
+    validate_trainingdb_electron_temperature_dataset(ds)
+
+    ds = to_xarray(
+        ids, "profiles_1d.electrons.temperature", "profiles_1d/electrons/density"
+    )
+    assert ds.data_vars.keys() == {
+        "profiles_1d.electrons.temperature",
+        "profiles_1d.electrons.density",
+    }
+
+
+def test_to_xarray():
+    ids = imas.IDSFactory("3.39.0").core_profiles()
+
+    ids.profiles_1d.resize(2)
+    ids.profiles_1d[0].electrons.temperature = [1.0, 2.0]
+    ids.profiles_1d[0].grid.rho_tor_norm = [0.0, 1.0]
+    ids.profiles_1d[0].time = 0.0
+
+    # These should all be identical:
+    ds1 = to_xarray(ids)
+    ds2 = to_xarray(ids, "profiles_1d.electrons.temperature")
+    ds3 = to_xarray(ids, "profiles_1d/electrons/temperature")
+    assert ds1.equals(ds2)
+    assert ds2.equals(ds3)

imas/util.py

@@ -1,8 +1,6 @@
 # This file is part of IMAS-Python.
 # You should have received the IMAS-Python LICENSE file with this project.
-"""Collection of useful helper methods when working with IMAS-Python.
-"""
-
+"""Collection of useful helper methods when working with IMAS-Python."""
 
 import logging
 import re
@@ -524,3 +522,77 @@ def get_data_dictionary_version(obj: Union[IDSBase, DBEntry, IDSFactory]) -> str
     if isinstance(obj, IDSBase):
         return obj._version
     raise TypeError(f"Cannot get data dictionary version of '{type(obj)}'")
+
+
+def to_xarray(ids: IDSToplevel, *paths: str) -> Any:
+    """Convert an IDS to an xarray Dataset.
+
+    Args:
+        ids: An IDS toplevel element
+        paths: Optional list of element paths to convert to xarray. The full IDS will be
+            converted to an xarray Dataset if no paths are provided.
+
+            Paths must not contain indices, and may use a ``/`` or a ``.`` as separator.
+            For example, ``"profiles_1d(itime)/electrons/density"`` is not allowed as
+            path, use ``"profiles_1d/electrons/density"`` or
+            ``profiles_1d.electrons.density"`` instead.
+
+            Coordinates to the quantities in the requested paths will also be included
+            in the xarray Dataset.
+
+    Returns:
+        An ``xarray.Dataset`` object.
+
+    Notes:
+        - Lazy loaded IDSs are not supported for full IDS conversion
+          (``imas.util.to_xarray(ids)`` will raise an exception for lazy loaded IDSs).
+          This function can work with lazy loaded IDSs when paths are explicitly
+          provided: this might take a while because it will load all data for the
+          provided paths and their coordinates.
+        - This function does not accept wildcards for the paths. However, it is possible
+          to combine this method with :py:func:`imas.util.find_paths`, see the Examples
+          below.
+        - This function may return an empty dataset in the following cases:
+
+          - The provided IDS does not contain any data.
+          - The IDS does not contain any data for the provided paths.
+          - The provided paths do not point to data nodes, but to (arrays of)
+            structures.
+
+    Examples:
+        .. code-block:: python
+
+            # Convert the whole IDS to an xarray Dataset
+            ds = imas.util.to_xarray(ids)
+
+            # Convert only some elements in the IDS (including their coordinates)
+            ds = imas.util.to_xarray(
+                ids,
+                "profiles_1d/electrons/density",
+                "profiles_1d/electrons/temperature",
+            )
+
+            # Paths can be provided with "/" or "." as separator
+            ds = imas.util.to_xarray(
+                ids,
+                "profiles_1d.electrons.density",
+                "profiles_1d.electrons.temperature",
+            )
+
+            # Combine with imas.util.find_paths to include all paths containing
+            # "profiles_1d" in the xarray conversion:
+            profiles_1d_paths = imas.util.find_paths(ids, "profiles_1d")
+            assert len(profiles_1d_paths) > 0
+            ds = imas.util.to_xarray(ids, *profiles_1d_paths)
+
+    See Also:
+        https://docs.xarray.dev/en/stable/generated/xarray.Dataset.html
+    """
+    try:
+        import xarray  # noqa: F401
+    except ImportError:
+        raise RuntimeError("xarray is not available, cannot convert the IDS to xarray.")
+
+    from imas._to_xarray import to_xarray
+
+    return to_xarray(ids, *paths)

{imas_python-1.2.1.dev13.dist-info → imas_python-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: imas-python
-Version: 1.2.1.dev13
+Version: 2.0.0
 Summary: Pythonic wrappers for the IMAS Access Layer
 Author: ITER Organization
 Author-email: Karel Lucas van de Plassche <karelvandeplassche@gmail.com>, Daan van Vugt <dvanvugt@ignitioncomputing.com>, Maarten Sebregts <msebregts@ignitioncomputing.com>, imas-support@iter.org
@@ -215,7 +215,7 @@ Requires-Dist: xxhash>=2
 Requires-Dist: saxonche
 Requires-Dist: gitpython
 Provides-Extra: all
-Requires-Dist: imas[docs,h5py,imas-core,netcdf,test]; extra == "all"
+Requires-Dist: imas-python[docs,test]; extra == "all"
 Provides-Extra: docs
 Requires-Dist: sphinx<7.0.0,>=6.0.0; extra == "docs"
 Requires-Dist: sphinx-autosummary-accessors>=0.1.2; extra == "docs"
@@ -225,6 +225,8 @@ Provides-Extra: netcdf
 Requires-Dist: netCDF4>=1.4.1; extra == "netcdf"
 Provides-Extra: h5py
 Requires-Dist: h5py; extra == "h5py"
+Provides-Extra: xarray
+Requires-Dist: xarray; extra == "xarray"
 Provides-Extra: test
 Requires-Dist: pytest>=5.4.1; extra == "test"
 Requires-Dist: pytest-cov>=0.6; extra == "test"
@@ -234,13 +236,13 @@ Requires-Dist: matplotlib; extra == "test"
 Requires-Dist: asv==0.6.1; extra == "test"
 Requires-Dist: virtualenv; extra == "test"
 Requires-Dist: pint; extra == "test"
-Requires-Dist: xarray; extra == "test"
+Requires-Dist: imas-python[h5py,netcdf,xarray]; extra == "test"
 
 # IMAS-Python
 
-IMAS-Python is a pure-python library to handle arbitrarily nested data structures.
-It is designed for, but not necessarily bound to, interacting with Interface 
-Data Structures (IDSs) as defined by the Integrated Modelling & Analysis Suite (IMAS) 
+IMAS-Python (formerly known as IMASPy its for versions < 2) is a pure-python library to handle 
+arbitrarily nested data structures. It is designed for, but not necessarily bound to, interacting 
+with Interface Data Structures (IDSs) as defined by the Integrated Modelling & Analysis Suite (IMAS) 
 Data Model.
 
 
@@ -266,11 +268,17 @@ factory = imas.IDSFactory()
 equilibrium = factory.equilibrium()
 print(equilibrium)
 
-equilibrium.ids_properties.homogeneous_time = imas.ids_defs.IDS_TIME_MODE_HETEROGENEOUS
+equilibrium.ids_properties.homogeneous_time = imas.ids_defs.IDS_TIME_MODE_HOMOGENEOUS
 equilibrium.ids_properties.comment = "testing"
+equilibrium.time = [0.01]
 
-with imas.DBEntry("imas:hdf5?path=./testdb","w") as dbentry:
+with imas.DBEntry("imas:hdf5?path=./testdb", "w") as dbentry:
     dbentry.put(equilibrium)
+	
+# or without imas_core dependency
+with imas.DBEntry("./test.nc", "w") as dbentry:
+    dbentry.put(equilibrium)
+
 ```
 
 A quick 5 minutes introduction is available in the documentation generated from `/docs/sources/intro.rst`.