Release 2.1.0

.github/workflows/test_with_pytest.yml

@@ -7,10 +7,10 @@ on:
 
 jobs:
   test:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]  # Test on multiple Python versions
+        python-version: ["3.10", "3.11", "3.12", "3.13"]  # Test on multiple Python versions
 
     steps:
       - name: Checkout repository
@@ -20,8 +20,6 @@ jobs:
 
         uses: actions/setup-python@v4
         with:
-          # until saxonche is available in 3.13
-          # https://saxonica.plan.io/issues/6561
           python-version: ${{ matrix.python-version }}
       - name: Display Python version
         run: python -c "import sys; print(sys.version)"

benchmarks/core_profiles.py

@@ -10,8 +10,6 @@
     available_serializers,
     available_slicing_backends,
     create_dbentry,
-    factory,
-    hlis,
 )
 
 N_SLICES = 32
@@ -26,13 +24,13 @@ def fill_slices(core_profiles, times):
         times: time values to fill a slice for
     """
     core_profiles.ids_properties.homogeneous_time = 1  # HOMOGENEOUS
-    core_profiles.ids_properties.comment = "Generated for the IMAS-Python benchmark suite"
+    core_profiles.ids_properties.comment = (
+        "Generated for the IMAS-Python benchmark suite"
+    )
     core_profiles.ids_properties.creation_date = datetime.date.today().isoformat()
     core_profiles.code.name = "IMAS-Python ASV benchmark"
     core_profiles.code.version = imas.__version__
-    core_profiles.code.repository = (
-        "https://github.com/iterorganization/IMAS-Python"
-    )
+    core_profiles.code.repository = "https://github.com/iterorganization/IMAS-Python"
 
     core_profiles.time = np.array(times)
     core_profiles.profiles_1d.resize(len(times))
@@ -50,13 +48,13 @@ def fill_slices(core_profiles, times):
         profiles_1d.ion.resize(len(ions))
         profiles_1d.neutral.resize(len(ions))
         for i, ion in enumerate(ions):
-            if hasattr(profiles_1d.ion[i], 'label'):
+            if hasattr(profiles_1d.ion[i], "label"):
                 profiles_1d.ion[i].label = ion
                 profiles_1d.neutral[i].label = ion
-            if hasattr(profiles_1d.ion[i], 'name'):
+            if hasattr(profiles_1d.ion[i], "name"):
                 profiles_1d.ion[i].name = ion
                 profiles_1d.neutral[i].name = ion
-            
+
             # profiles_1d.ion[i].label = profiles_1d.neutral[i].label = ion
             profiles_1d.ion[i].z_ion = 1.0
             profiles_1d.ion[i].neutral_index = profiles_1d.neutral[i].ion_index = i + 1
@@ -70,31 +68,31 @@ def fill_slices(core_profiles, times):
 
 
 class GetSlice:
-    params = [hlis, available_slicing_backends]
-    param_names = ["hli", "backend"]
+    params = [available_slicing_backends]
+    param_names = ["backend"]
 
-    def setup(self, hli, backend):
-        self.dbentry = create_dbentry(hli, backend)
-        core_profiles = factory[hli].core_profiles()
+    def setup(self, backend):
+        self.dbentry = create_dbentry(backend)
+        core_profiles = imas.IDSFactory().core_profiles()
         fill_slices(core_profiles, TIME)
         self.dbentry.put(core_profiles)
 
-    def time_get_slice(self, hli, backend):
+    def time_get_slice(self, backend):
         for t in TIME:
             self.dbentry.get_slice("core_profiles", t, imas.ids_defs.CLOSEST_INTERP)
 
-    def teardown(self, hli, backend):
+    def teardown(self, backend):
         if hasattr(self, "dbentry"):  # imas + netCDF has no dbentry
             self.dbentry.close()
 
 
 class Get:
-    params = [hlis, available_backends]
-    param_names = ["hli", "backend"]
+    params = [available_backends]
+    param_names = ["backend"]
     setup = GetSlice.setup
     teardown = GetSlice.teardown
 
-    def time_get(self, hli, backend):
+    def time_get(self, backend):
         self.dbentry.get("core_profiles")
 
 
@@ -103,8 +101,8 @@ class LazyGet:
     param_names = ["lazy", "backend"]
 
     def setup(self, lazy, backend):
-        self.dbentry = create_dbentry("imas", backend)
-        core_profiles = factory["imas"].core_profiles()
+        self.dbentry = create_dbentry(backend)
+        core_profiles = imas.IDSFactory().core_profiles()
         fill_slices(core_profiles, TIME)
         self.dbentry.put(core_profiles)
 
@@ -118,75 +116,72 @@ def teardown(self, lazy, backend):
 
 
 class Generate:
-    params = [hlis]
-    param_names = ["hli"]
+    def setup(self):
+        self.core_profiles = imas.IDSFactory().core_profiles()
 
-    def setup(self, hli):
-        self.core_profiles = factory[hli].core_profiles()
-
-    def time_generate(self, hli):
+    def time_generate(self):
         fill_slices(self.core_profiles, TIME)
 
-    def time_generate_slices(self, hli):
+    def time_generate_slices(self):
         for t in TIME:
             fill_slices(self.core_profiles, [t])
 
-    def time_create_core_profiles(self, hli):
-        factory[hli].core_profiles()
+    def time_create_core_profiles(self):
+        imas.IDSFactory().core_profiles()
 
 
 class Put:
-    params = [["0", "1"], hlis, available_backends]
+    params = [["0", "1"], available_backends]
     param_names = ["disable_validate", "hli", "backend"]
 
-    def setup(self, disable_validate, hli, backend):
-        create_dbentry(hli, backend).close()  # catch unsupported combinations
-        self.core_profiles = factory[hli].core_profiles()
+    def setup(self, disable_validate, backend):
+        create_dbentry(backend).close()  # catch unsupported combinations
+        self.core_profiles = imas.IDSFactory().core_profiles()
         fill_slices(self.core_profiles, TIME)
         os.environ["IMAS_AL_DISABLE_VALIDATE"] = disable_validate
 
-    def time_put(self, disable_validate, hli, backend):
-        with create_dbentry(hli, backend) as dbentry:
+    def time_put(self, disable_validate, backend):
+        with create_dbentry(backend) as dbentry:
             dbentry.put(self.core_profiles)
 
 
 class PutSlice:
-    params = [["0", "1"], hlis, available_slicing_backends]
-    param_names = ["disable_validate", "hli", "backend"]
+    params = [["0", "1"], available_slicing_backends]
+    param_names = ["disable_validate", "backend"]
 
-    def setup(self, disable_validate, hli, backend):
-        create_dbentry(hli, backend).close()  # catch unsupported combinations
-        self.core_profiles = factory[hli].core_profiles()
+    def setup(self, disable_validate, backend):
+        create_dbentry(backend).close()  # catch unsupported combinations
+        self.core_profiles = imas.IDSFactory().core_profiles()
         os.environ["IMAS_AL_DISABLE_VALIDATE"] = disable_validate
 
-    def time_put_slice(self, disable_validate, hli, backend):
-        with create_dbentry(hli, backend) as dbentry:
+    def time_put_slice(self, disable_validate, backend):
+        with create_dbentry(backend) as dbentry:
             for t in TIME:
                 fill_slices(self.core_profiles, [t])
                 dbentry.put_slice(self.core_profiles)
 
 
 class Serialize:
-    params = [hlis, available_serializers]
-    param_names = ["hli", "serializer"]
+    params = [available_serializers]
+    param_names = ["serializer"]
 
-    def setup(self, hli, serializer):
-        self.core_profiles = factory[hli].core_profiles()
+    def setup(self, serializer):
+        self.core_profiles = imas.IDSFactory().core_profiles()
         fill_slices(self.core_profiles, TIME)
 
-    def time_serialize(self, hli, serializer):
+    def time_serialize(self, serializer):
         self.core_profiles.serialize(serializer)
 
 
 class Deserialize:
-    params = [hlis, available_serializers]
-    param_names = ["hli", "serializer"]
+    params = [available_serializers]
+    param_names = ["serializer"]
 
-    def setup(self, hli, serializer):
-        self.core_profiles = factory[hli].core_profiles()
+    def setup(self, serializer):
+        self.core_profiles = imas.IDSFactory().core_profiles()
         fill_slices(self.core_profiles, TIME)
         self.data = self.core_profiles.serialize(serializer)
-        self.core_profiles = factory[hli].core_profiles()
+        self.core_profiles = imas.IDSFactory().core_profiles()
 
-    def time_deserialize(self, hli, serializer):
+    def time_deserialize(self, serializer):
         self.core_profiles.deserialize(self.data)

benchmarks/edge_profiles.py

@@ -5,7 +5,7 @@
 
 import imas
 
-from .utils import available_backends, create_dbentry, factory, hlis
+from .utils import available_backends, create_dbentry
 
 N_POINTS = 600  # number of random R,Z points
 N_LINES = 1200  # number of random lines in R,Z plane
@@ -27,9 +27,7 @@ def fill_ggd(edge_profiles, times):
     edge_profiles.ids_properties.creation_date = datetime.date.today().isoformat()
     edge_profiles.code.name = "IMAS-Python ASV benchmark"
     edge_profiles.code.version = imas.__version__
-    edge_profiles.code.repository = (
-        "https://github.com/iterorganization/IMAS-Python"
-    )
+    edge_profiles.code.repository = "https://github.com/iterorganization/IMAS-Python"
 
     # This GGD grid is not a valid description, but it's a good stress test for the
     # typical access patterns that exist in GGD grids
@@ -124,45 +122,42 @@ def fill_ggd(edge_profiles, times):
 
 
 class Get:
-    params = [hlis, available_backends]
-    param_names = ["hli", "backend"]
+    params = [available_backends]
+    param_names = ["backend"]
 
-    def setup(self, hli, backend):
-        self.dbentry = create_dbentry(hli, backend)
-        edge_profiles = factory[hli].edge_profiles()
+    def setup(self, backend):
+        self.dbentry = create_dbentry(backend)
+        edge_profiles = imas.IDSFactory().edge_profiles()
         fill_ggd(edge_profiles, TIME)
         self.dbentry.put(edge_profiles)
 
-    def time_get(self, hli, backend):
+    def time_get(self, backend):
         self.dbentry.get("edge_profiles")
 
-    def teardown(self, hli, backend):
+    def teardown(self, backend):
         if hasattr(self, "dbentry"):  # imas + netCDF has no dbentry
             self.dbentry.close()
 
 
 class Generate:
-    params = [hlis]
-    param_names = ["hli"]
-
-    def time_generate(self, hli):
-        edge_profiles = factory[hli].edge_profiles()
+    def time_generate(self):
+        edge_profiles = imas.IDSFactory().edge_profiles()
         fill_ggd(edge_profiles, TIME)
 
-    def time_create_edge_profiles(self, hli):
-        factory[hli].edge_profiles()
+    def time_create_edge_profiles(self):
+        imas.IDSFactory().edge_profiles()
 
 
 class Put:
-    params = [["0", "1"], hlis, available_backends]
-    param_names = ["disable_validate", "hli", "backend"]
+    params = [["0", "1"], available_backends]
+    param_names = ["disable_validate", "backend"]
 
-    def setup(self, disable_validate, hli, backend):
-        create_dbentry(hli, backend).close()  # catch unsupported combinations
-        self.edge_profiles = factory[hli].edge_profiles()
+    def setup(self, disable_validate, backend):
+        create_dbentry(backend).close()  # catch unsupported combinations
+        self.edge_profiles = imas.IDSFactory().edge_profiles()
         fill_ggd(self.edge_profiles, TIME)
         os.environ["IMAS_AL_DISABLE_VALIDATE"] = disable_validate
 
-    def time_put(self, disable_validate, hli, backend):
-        with create_dbentry(hli, backend) as dbentry:
+    def time_put(self, disable_validate, backend):
+        with create_dbentry(backend) as dbentry:
             dbentry.put(self.edge_profiles)

benchmarks/utils.py

@@ -1,10 +1,10 @@
-import importlib
 import logging
 import uuid
 from pathlib import Path
 
 import imas
 import imas.exception
+import imas.ids_defs
 
 # Backend constants
 HDF5 = "HDF5"
@@ -56,28 +56,12 @@ def backend_exists(backend):
     backend for backend in available_backends if backend not in [ASCII, NETCDF]
 ]
 
-hlis = ["imas"]
-DBEntry = {
-    "imas": imas.DBEntry,
-}
-factory = {
-    "imas": imas.IDSFactory(),
-}
-available_serializers = [imas.ids_defs.ASCII_SERIALIZER_PROTOCOL]
-
+available_serializers = [
+    imas.ids_defs.ASCII_SERIALIZER_PROTOCOL,
+    imas.ids_defs.FLEXBUFFERS_SERIALIZER_PROTOCOL,
+]
 
-def create_dbentry(hli, backend):
-    if backend == NETCDF:
-        if hli == "imas":  # check if netcdf backend is available
-            try:
-                assert (
-                    imas.DBEntry._select_implementation("x.nc").__name__
-                    == "NCDBEntryImpl"
-                )
-            except (AttributeError, AssertionError):
-                raise NotImplementedError(
-                    "This version of IMAS-Python doesn't implement netCDF."
-                ) from None
 
-    path = Path.cwd() / f"DB-{hli}-{backend}"
-    return DBEntry[hli](create_uri(backend, path), "w")
+def create_dbentry(backend):
+    path = Path.cwd() / f"DB-{backend}"
+    return imas.DBEntry(create_uri(backend, path), "w")

conftest.py

@@ -70,6 +70,13 @@ def pytest_addoption(parser):
     "hdf5": HDF5_BACKEND,
     "mdsplus": MDSPLUS_BACKEND,
 }
+try:
+    from imas.db_entry import DBEntry
+    from imas_core.exception import ImasCoreBackendException
+    DBEntry("imas:mdsplus?path=dummy","r")
+except ImasCoreBackendException as iex:
+    if "not available" in str(iex.message):
+        _BACKENDS.pop("mdsplus")
 
 
 try: