compatibility fixes for xarray 0.18

they changed the backend infrastructure. Now, it is only possible to get the file name if the dataset has been opened with psy.open_dataset or psy.open_mfdataset The store will always be guessed.
Chilipp · Sep 29, 2021 · Sep 16, 2021 · Sep 16, 2021 · Sep 16, 2021 · Sep 22, 2021
commit cd2e49d788a3b50c824521afff5aef4488d93d83
diff --git a/psyplot/data.py b/psyplot/data.py
@@ -13,6 +13,7 @@
 import xarray as xr
 from xarray.core.utils import NDArrayMixin
 from xarray.core.formatting import first_n_items, format_item
+
 import xarray.backends.api as xarray_api
 from pandas import to_datetime
 import numpy as np
@@ -33,6 +34,11 @@
 except ImportError:
     with_dask = False
 
+try:
+    import xarray.backends.plugins as xr_plugins
+except ImportError:
+    xr_plugins = None  # type: ignore
+
 
 # No data variable. This is used for filtering if an attribute could not have
 # been accessed
@@ -487,6 +493,38 @@ def tmp_it():
         while True:
             yield NamedTemporaryFile(suffix='.nc').name
 
+    def _legacy_get_filename_ds(ds):
+        # try to get the filename from the data store of the obj
+        #
+        # Outdated possibility since the backend plugin methodology of
+        # xarray 0.18
+        if store_mod is not None:
+            store = ds._file_obj
+            # try several engines
+            if hasattr(store, 'file_objs'):
+                fname = []
+                store_mod = []
+                store_cls = []
+                for obj in store.file_objs:  # mfdataset
+                    _fname = None
+                    for func in get_fname_funcs:
+                        if _fname is None:
+                            _fname = func(obj)
+                            if _fname is not None:
+                                fname.append(_fname)
+                                store_mod.append(obj.__module__)
+                                store_cls.append(obj.__class__.__name__)
+                fname = tuple(fname)
+                store_mod = tuple(store_mod)
+                store_cls = tuple(store_cls)
+            else:
+                for func in get_fname_funcs:
+                    fname = func(store)
+                    if fname is not None:
+                        break
+
+        return fname, store_mod, store_cls
+
     fname = None
     if paths is True or (dump and paths is None):
         paths = tmp_it()
@@ -495,32 +533,15 @@ def tmp_it():
             paths = iter([paths])
         else:
             paths = iter(paths)
-    # try to get the filename from  the data store of the obj
     store_mod, store_cls = ds.psy.data_store
-    if store_mod is not None:
-        store = ds._file_obj
-        # try several engines
-        if hasattr(store, 'file_objs'):
-            fname = []
-            store_mod = []
-            store_cls = []
-            for obj in store.file_objs:  # mfdataset
-                _fname = None
-                for func in get_fname_funcs:
-                    if _fname is None:
-                        _fname = func(obj)
-                        if _fname is not None:
-                            fname.append(_fname)
-                            store_mod.append(obj.__module__)
-                            store_cls.append(obj.__class__.__name__)
-            fname = tuple(fname)
-            store_mod = tuple(store_mod)
-            store_cls = tuple(store_cls)
-        else:
-            for func in get_fname_funcs:
-                fname = func(store)
-                if fname is not None:
-                    break
+    if xr_plugins is None:
+        fname, store_mod, store_cls = _legacy_get_filename_ds(ds)
+    elif "source" in ds.encoding:
+        fname = ds.encoding["source"]
+        store_mod = None
+        store_cls = None
+
+
     # check if paths is provided and if yes, save the file
     if fname is None and paths is not None:
         fname = next(paths, None)
@@ -2004,6 +2025,8 @@ def open_dataset(filename_or_obj, decode_cf=True, decode_times=True,
     ds = xr.open_dataset(filename_or_obj, decode_cf=decode_cf,
                          decode_coords=False, engine=engine,
                          decode_times=decode_times, **kwargs)
+    if isstring(filename_or_obj):
+        ds.psy.filename = filename_or_obj
     if decode_cf:
         ds = CFDecoder.decode_ds(
             ds, decode_coords=decode_coords, decode_times=decode_times,
@@ -2060,15 +2083,21 @@ def open_mfdataset(paths, decode_cf=True, decode_times=True,
         kwargs['concat_dim'] = 'time'
         if xr_version > (0, 11):
             kwargs['combine'] = 'nested'
+    if all(map(isstring, paths)):
+        filenames = list(paths)
+    else:
+        filenames = None
     if engine == 'gdal':
         from psyplot.gdal_store import GdalStore
         paths = list(map(GdalStore, paths))
         engine = None
-        kwargs['lock'] = False
+        if xr_version < (0, 18):
+            kwargs['lock'] = False
 
     ds = xr.open_mfdataset(
         paths, decode_cf=decode_cf, decode_times=decode_times, engine=engine,
         decode_coords=False, **kwargs)
+    ds.psy.filename = filenames
     if decode_cf:
         ds = CFDecoder.decode_ds(ds, gridfile=gridfile,
                                  decode_coords=decode_coords,
@@ -4981,6 +5010,9 @@ def _open_ds_from_store(fname, store_mod=None, store_cls=None, **kwargs):
                 kwargs['engine'] = None
                 kwargs['lock'] = False
                 return open_mfdataset(fname, **kwargs)
+            else:
+                # try guessing with open_dataset
+                return open_mfdataset(fname, **kwargs)
     if store_mod is not None and store_cls is not None:
         fname = _open_store(store_mod, store_cls, fname)
     return open_dataset(fname, **kwargs)

diff --git a/tests/test_data.py b/tests/test_data.py
@@ -1322,6 +1322,10 @@ def test_array_info(self):
             name=[['v1', ['v3', 'v4']], ['v1', 'v2']], prefer_list=True)
         l.extend(ds2.psy.create_list(name=['t2m'], x=0, t=1),
                  new_name=True)
+        if xr_version < (0, 18):
+            nc_store = ('xarray.backends.netCDF4_', 'NetCDF4DataStore')
+        else:
+            nc_store = (None, None)
         self.assertEqual(l.array_info(engine='netCDF4'), OrderedDict([
             # first list contating an array with two variables
             ('arr0', OrderedDict([
@@ -1345,8 +1349,7 @@ def test_array_info(self):
             ('arr2', {'dims': {'z': slice(None), 'y': slice(None),
                                't': 1, 'x': 0},
                       'attrs': ds2.t2m.attrs,
-                      'store': ('xarray.backends.netCDF4_',
-                                'NetCDF4DataStore'),
+                      'store': nc_store,
                       'name': 't2m', 'fname': fname}),
             ('attrs', OrderedDict())]))
         return l
@@ -1398,6 +1401,8 @@ def test_from_dict_03_mfdataset(self):
         # now open the mfdataset
         ds = psyd.open_mfdataset([fname1, fname2])
         l = self.list_class.from_dataset(ds, name=['v0'], time=[0, 3])
+        if xr_version >= (0, 18):
+            ds.psy.filename = [fname1, fname2]
         self.assertEqual(
             self.list_class.from_dict(l.array_info()).array_info(),
             l.array_info())
@@ -1557,14 +1562,17 @@ def _test_engine(self, engine):
         ds.close()
         os.remove(dumped_fname)
 
+    @unittest.skipIf(xr_version >= (0, 18), "Not supported for xarray>=0.18")
     @unittest.skipIf(not with_nio, 'Nio module not installed')
     def test_nio(self):
         self._test_engine('pynio')
 
+    @unittest.skipIf(xr_version >= (0, 18), "Not supported for xarray>=0.18")
     @unittest.skipIf(not with_netcdf4, 'netCDF4 module not installed')
     def test_netcdf4(self):
         self._test_engine('netcdf4')
 
+    @unittest.skipIf(xr_version >= (0, 18), "Not supported for xarray>=0.18")
     @unittest.skipIf(not with_scipy, 'scipy module not installed')
     def test_scipy(self):
         self._test_engine('scipy')