Bugfix in list_engine (#4811)

* fix list_engine

* fix store engine and netcdf4

* reve

* revert changes in guess_engine

* add resister of backend if dependencies aere instralled

* style mypy

* fix import

* use import instead of importlib

* black

* replace ImportError with ModuleNotFoundError

* fix typo

* fix typos

* remove else

* Revert remove imports inside backends functions

* Revert remove imports inside cfgrib

* modify check on imports inside the backends

* remove not used import

xarray/backends/cfgrib_.py

@@ -5,10 +5,23 @@
 from ..core import indexing
 from ..core.utils import Frozen, FrozenDict, close_on_error
 from ..core.variable import Variable
-from .common import AbstractDataStore, BackendArray, BackendEntrypoint
+from .common import (
+    BACKEND_ENTRYPOINTS,
+    AbstractDataStore,
+    BackendArray,
+    BackendEntrypoint,
+)
 from .locks import SerializableLock, ensure_lock
 from .store import open_backend_dataset_store
 
+try:
+    import cfgrib
+
+    has_cfgrib = True
+except ModuleNotFoundError:
+    has_cfgrib = False
+
+
 # FIXME: Add a dedicated lock, even if ecCodes is supposed to be thread-safe
 #   in most circumstances. See:
 #       https://confluence.ecmwf.int/display/ECC/Frequently+Asked+Questions
@@ -38,7 +51,6 @@ class CfGribDataStore(AbstractDataStore):
     """
 
     def __init__(self, filename, lock=None, **backend_kwargs):
-        import cfgrib
 
         if lock is None:
             lock = ECCODES_LOCK
@@ -129,3 +141,7 @@ def open_backend_dataset_cfgrib(
 cfgrib_backend = BackendEntrypoint(
     open_dataset=open_backend_dataset_cfgrib, guess_can_open=guess_can_open_cfgrib
 )
+
+
+if has_cfgrib:
+    BACKEND_ENTRYPOINTS["cfgrib"] = cfgrib_backend

xarray/backends/common.py

@@ -1,6 +1,7 @@
 import logging
 import time
 import traceback
+from typing import Dict
 
 import numpy as np
 
@@ -349,3 +350,6 @@ def __init__(self, open_dataset, open_dataset_parameters=None, guess_can_open=No
         self.open_dataset = open_dataset
         self.open_dataset_parameters = open_dataset_parameters
         self.guess_can_open = guess_can_open
+
+
+BACKEND_ENTRYPOINTS: Dict[str, BackendEntrypoint] = {}

xarray/backends/h5netcdf_.py

@@ -8,7 +8,12 @@
 from ..core import indexing
 from ..core.utils import FrozenDict, is_remote_uri, read_magic_number
 from ..core.variable import Variable
-from .common import BackendEntrypoint, WritableCFDataStore, find_root_and_group
+from .common import (
+    BACKEND_ENTRYPOINTS,
+    BackendEntrypoint,
+    WritableCFDataStore,
+    find_root_and_group,
+)
 from .file_manager import CachingFileManager, DummyFileManager
 from .locks import HDF5_LOCK, combine_locks, ensure_lock, get_write_lock
 from .netCDF4_ import (
@@ -20,6 +25,13 @@
 )
 from .store import open_backend_dataset_store
 
+try:
+    import h5netcdf
+
+    has_h5netcdf = True
+except ModuleNotFoundError:
+    has_h5netcdf = False
+
 
 class H5NetCDFArrayWrapper(BaseNetCDF4Array):
     def get_array(self, needs_lock=True):
@@ -85,8 +97,6 @@ class H5NetCDFStore(WritableCFDataStore):
 
     def __init__(self, manager, group=None, mode=None, lock=HDF5_LOCK, autoclose=False):
 
-        import h5netcdf
-
         if isinstance(manager, (h5netcdf.File, h5netcdf.Group)):
             if group is None:
                 root, group = find_root_and_group(manager)
@@ -122,7 +132,6 @@ def open(
         invalid_netcdf=None,
         phony_dims=None,
     ):
-        import h5netcdf
 
         if isinstance(filename, bytes):
             raise ValueError(
@@ -375,3 +384,6 @@ def open_backend_dataset_h5netcdf(
 h5netcdf_backend = BackendEntrypoint(
     open_dataset=open_backend_dataset_h5netcdf, guess_can_open=guess_can_open_h5netcdf
 )
+
+if has_h5netcdf:
+    BACKEND_ENTRYPOINTS["h5netcdf"] = h5netcdf_backend

xarray/backends/netCDF4_.py

@@ -12,6 +12,7 @@
 from ..core.utils import FrozenDict, close_on_error, is_remote_uri
 from ..core.variable import Variable
 from .common import (
+    BACKEND_ENTRYPOINTS,
     BackendArray,
     BackendEntrypoint,
     WritableCFDataStore,
@@ -23,6 +24,14 @@
 from .netcdf3 import encode_nc3_attr_value, encode_nc3_variable
 from .store import open_backend_dataset_store
 
+try:
+    import netCDF4
+
+    has_netcdf4 = True
+except ModuleNotFoundError:
+    has_netcdf4 = False
+
+
 # This lookup table maps from dtype.byteorder to a readable endian
 # string used by netCDF4.
 _endian_lookup = {"=": "native", ">": "big", "<": "little", "|": "native"}
@@ -298,7 +307,6 @@ class NetCDF4DataStore(WritableCFDataStore):
     def __init__(
         self, manager, group=None, mode=None, lock=NETCDF4_PYTHON_LOCK, autoclose=False
     ):
-        import netCDF4
 
         if isinstance(manager, netCDF4.Dataset):
             if group is None:
@@ -335,7 +343,6 @@ def open(
         lock_maker=None,
         autoclose=False,
     ):
-        import netCDF4
 
         if isinstance(filename, pathlib.Path):
             filename = os.fspath(filename)
@@ -563,3 +570,7 @@ def open_backend_dataset_netcdf4(
 netcdf4_backend = BackendEntrypoint(
     open_dataset=open_backend_dataset_netcdf4, guess_can_open=guess_can_open_netcdf4
 )
+
+
+if has_netcdf4:
+    BACKEND_ENTRYPOINTS["netcdf4"] = netcdf4_backend

xarray/backends/plugins.py

@@ -2,33 +2,11 @@
 import inspect
 import itertools
 import logging
-import typing as T
 import warnings
 
 import pkg_resources
 
-from .cfgrib_ import cfgrib_backend
-from .common import BackendEntrypoint
-from .h5netcdf_ import h5netcdf_backend
-from .netCDF4_ import netcdf4_backend
-from .pseudonetcdf_ import pseudonetcdf_backend
-from .pydap_ import pydap_backend
-from .pynio_ import pynio_backend
-from .scipy_ import scipy_backend
-from .store import store_backend
-from .zarr import zarr_backend
-
-BACKEND_ENTRYPOINTS: T.Dict[str, BackendEntrypoint] = {
-    "store": store_backend,
-    "netcdf4": netcdf4_backend,
-    "h5netcdf": h5netcdf_backend,
-    "scipy": scipy_backend,
-    "pseudonetcdf": pseudonetcdf_backend,
-    "zarr": zarr_backend,
-    "cfgrib": cfgrib_backend,
-    "pydap": pydap_backend,
-    "pynio": pynio_backend,
-}
+from .common import BACKEND_ENTRYPOINTS
 
 
 def remove_duplicates(backend_entrypoints):

xarray/backends/pseudonetcdf_.py

@@ -3,11 +3,24 @@
 from ..core import indexing
 from ..core.utils import Frozen, FrozenDict, close_on_error
 from ..core.variable import Variable
-from .common import AbstractDataStore, BackendArray, BackendEntrypoint
+from .common import (
+    BACKEND_ENTRYPOINTS,
+    AbstractDataStore,
+    BackendArray,
+    BackendEntrypoint,
+)
 from .file_manager import CachingFileManager
 from .locks import HDF5_LOCK, NETCDFC_LOCK, combine_locks, ensure_lock
 from .store import open_backend_dataset_store
 
+try:
+    from PseudoNetCDF import pncopen
+
+    has_pseudonetcdf = True
+except ModuleNotFoundError:
+    has_pseudonetcdf = False
+
+
 # psuedonetcdf can invoke netCDF libraries internally
 PNETCDF_LOCK = combine_locks([HDF5_LOCK, NETCDFC_LOCK])
 
@@ -40,7 +53,6 @@ class PseudoNetCDFDataStore(AbstractDataStore):
 
     @classmethod
     def open(cls, filename, lock=None, mode=None, **format_kwargs):
-        from PseudoNetCDF import pncopen
 
         keywords = {"kwargs": format_kwargs}
         # only include mode if explicitly passed
@@ -138,3 +150,7 @@ def open_backend_dataset_pseudonetcdf(
     open_dataset=open_backend_dataset_pseudonetcdf,
     open_dataset_parameters=open_dataset_parameters,
 )
+
+
+if has_pseudonetcdf:
+    BACKEND_ENTRYPOINTS["pseudonetcdf"] = pseudonetcdf_backend

xarray/backends/pydap_.py

@@ -4,9 +4,22 @@
 from ..core.pycompat import integer_types
 from ..core.utils import Frozen, FrozenDict, close_on_error, is_dict_like, is_remote_uri
 from ..core.variable import Variable
-from .common import AbstractDataStore, BackendArray, BackendEntrypoint, robust_getitem
+from .common import (
+    BACKEND_ENTRYPOINTS,
+    AbstractDataStore,
+    BackendArray,
+    BackendEntrypoint,
+    robust_getitem,
+)
 from .store import open_backend_dataset_store
 
+try:
+    import pydap.client
+
+    has_pydap = True
+except ModuleNotFoundError:
+    has_pydap = False
+
 
 class PydapArrayWrapper(BackendArray):
     def __init__(self, array):
@@ -74,7 +87,6 @@ def __init__(self, ds):
 
     @classmethod
     def open(cls, url, session=None):
-        import pydap.client
 
         ds = pydap.client.open_url(url, session=session)
         return cls(ds)
@@ -133,3 +145,7 @@ def open_backend_dataset_pydap(
 pydap_backend = BackendEntrypoint(
     open_dataset=open_backend_dataset_pydap, guess_can_open=guess_can_open_pydap
 )
+
+
+if has_pydap:
+    BACKEND_ENTRYPOINTS["pydap"] = pydap_backend

xarray/backends/pynio_.py

@@ -3,11 +3,24 @@
 from ..core import indexing
 from ..core.utils import Frozen, FrozenDict, close_on_error
 from ..core.variable import Variable
-from .common import AbstractDataStore, BackendArray, BackendEntrypoint
+from .common import (
+    BACKEND_ENTRYPOINTS,
+    AbstractDataStore,
+    BackendArray,
+    BackendEntrypoint,
+)
 from .file_manager import CachingFileManager
 from .locks import HDF5_LOCK, NETCDFC_LOCK, SerializableLock, combine_locks, ensure_lock
 from .store import open_backend_dataset_store
 
+try:
+    import Nio
+
+    has_pynio = True
+except ModuleNotFoundError:
+    has_pynio = False
+
+
 # PyNIO can invoke netCDF libraries internally
 # Add a dedicated lock just in case NCL as well isn't thread-safe.
 NCL_LOCK = SerializableLock()
@@ -45,7 +58,6 @@ class NioDataStore(AbstractDataStore):
     """Store for accessing datasets via PyNIO"""
 
     def __init__(self, filename, mode="r", lock=None, **kwargs):
-        import Nio
 
         if lock is None:
             lock = PYNIO_LOCK
@@ -119,3 +131,7 @@ def open_backend_dataset_pynio(
 
 
 pynio_backend = BackendEntrypoint(open_dataset=open_backend_dataset_pynio)
+
+
+if has_pynio:
+    BACKEND_ENTRYPOINTS["pynio"] = pynio_backend

xarray/backends/scipy_.py

@@ -6,12 +6,24 @@
 from ..core.indexing import NumpyIndexingAdapter
 from ..core.utils import Frozen, FrozenDict, close_on_error, read_magic_number
 from ..core.variable import Variable
-from .common import BackendArray, BackendEntrypoint, WritableCFDataStore
+from .common import (
+    BACKEND_ENTRYPOINTS,
+    BackendArray,
+    BackendEntrypoint,
+    WritableCFDataStore,
+)
 from .file_manager import CachingFileManager, DummyFileManager
 from .locks import ensure_lock, get_write_lock
 from .netcdf3 import encode_nc3_attr_value, encode_nc3_variable, is_valid_nc3_name
 from .store import open_backend_dataset_store
 
+try:
+    import scipy.io
+
+    has_scipy = True
+except ModuleNotFoundError:
+    has_scipy = False
+
 
 def _decode_string(s):
     if isinstance(s, bytes):
@@ -61,8 +73,6 @@ def __setitem__(self, key, value):
 def _open_scipy_netcdf(filename, mode, mmap, version):
     import gzip
 
-    import scipy.io
-
     # if the string ends with .gz, then gunzip and open as netcdf file
     if isinstance(filename, str) and filename.endswith(".gz"):
         try:
@@ -271,3 +281,7 @@ def open_backend_dataset_scipy(
 scipy_backend = BackendEntrypoint(
     open_dataset=open_backend_dataset_scipy, guess_can_open=guess_can_open_scipy
 )
+
+
+if has_scipy:
+    BACKEND_ENTRYPOINTS["scipy"] = scipy_backend

xarray/backends/store.py

@@ -1,6 +1,6 @@
 from .. import conventions
 from ..core.dataset import Dataset
-from .common import AbstractDataStore, BackendEntrypoint
+from .common import BACKEND_ENTRYPOINTS, AbstractDataStore, BackendEntrypoint
 
 
 def guess_can_open_store(store_spec):
@@ -44,3 +44,6 @@ def open_backend_dataset_store(
 store_backend = BackendEntrypoint(
     open_dataset=open_backend_dataset_store, guess_can_open=guess_can_open_store
 )
+
+
+BACKEND_ENTRYPOINTS["store"] = store_backend