Bug#973115: marked as done (cfgrib: FTBFS: tests failed)

[Debian Bug Tracking System]

Your message dated Tue, 10 Nov 2020 15:18:20 +0000
with message-id <e1kcvpy-0009bu...@fasolo.debian.org>
and subject line Bug#973115: fixed in cfgrib 0.9.8.4-2
has caused the Debian Bug report #973115,
regarding cfgrib: FTBFS: tests failed
to be marked as done.

This means that you claim that the problem has been dealt with.
If this is not the case it is now your responsibility to reopen the
Bug report if necessary, and/or fix the problem forthwith.

(NB: If you are a system administrator and have no idea what this
message is talking about, this may indicate a serious mail system
misconfiguration somewhere. Please contact ow...@bugs.debian.org
immediately.)


-- 
973115: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=973115
Debian Bug Tracking System
Contact ow...@bugs.debian.org with problems

--- Begin Message ---

Source: cfgrib
Version: 0.9.8.4-1
Severity: serious
Justification: FTBFS on amd64
Tags: bullseye sid ftbfs
Usertags: ftbfs-20201027 ftbfs-bullseye

Hi,

During a rebuild of all packages in sid, your package failed to build
on amd64.

Relevant part (hopefully):
> make[1]: Entering directory '/<<PKGBUILDDIR>>'
> for p in python3.9 python3.8; do \
> PY3VERNUM=`echo $p | sed -e 's/python//' `; \
>       pybuild --test --test-pytest -i $p -p $PY3VERNUM  ;  \
>                 done
> I: pybuild base:217: cd /<<PKGBUILDDIR>>/.pybuild/cpython3_3.9_cfgrib/build; 
> python3.9 -m pytest tests
> ============================= test session starts 
> ==============================
> platform linux -- Python 3.9.0+, pytest-4.6.11, py-1.9.0, pluggy-0.13.0
> rootdir: /<<PKGBUILDDIR>>, inifile: setup.cfg
> collected 122 items / 1 skipped / 121 selected
> 
> tests/test_10_bindings.py ........................                       [ 
> 19%]
> tests/test_10_cfunits.py .                                               [ 
> 20%]
> tests/test_20_cfcoords.py ......                                         [ 
> 25%]
> tests/test_20_main.py .                                                  [ 
> 26%]
> tests/test_20_messages.py .........                                      [ 
> 33%]
> tests/test_25_cfmessage.py .....                                         [ 
> 37%]
> tests/test_30_dataset.py ...................                             [ 
> 53%]
> tests/test_40_xarray_store.py .......                                    [ 
> 59%]
> tests/test_40_xarray_to_grib_regular_ll.py FF.FF                         [ 
> 63%]
> tests/test_50_datamodels.py ..                                           [ 
> 64%]
> tests/test_50_sample_data.py ....................FFxFFFFxFFFxF           [ 
> 91%]
> tests/test_50_xarray_getitem.py ..........                               
> [100%]
> 
> =================================== FAILURES 
> ===================================
> _______________ test_canonical_dataarray_to_grib_with_grib_keys 
> ________________
> 
> canonic_da = <xarray.DataArray (time: 4, step: 2, isobaricInhPa: 3, latitude: 
> 5, longitude: 6)>
> array([[[[[0., 0., 0., 0., 0., 0.],...   (latitude) float64 90.0 45.0 0.0 
> -45.0 -90.0
>   * longitude      (longitude) float64 0.0 60.0 120.0 180.0 240.0 300.0
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-5/test_canonical_dataarray_to_gr0')
> 
>     def test_canonical_dataarray_to_grib_with_grib_keys(canonic_da, tmpdir):
>         out_path = tmpdir.join('res.grib')
>         grib_keys = {'gridType': 'regular_ll'}
>         with open(str(out_path), 'wb') as file:
> >           xarray_to_grib.canonical_dataarray_to_grib(canonic_da, file, 
> > grib_keys=grib_keys)
> 
> tests/test_40_xarray_to_grib_regular_ll.py:30: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 12:00:00',
>                '2018-01-02 00:00:00', '2018-01-02 12:00:00'],
>               dtype='datetime64[ns]', name='time', freq=None)
> key = 1514764800000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1514764800000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ______________ test_canonical_dataarray_to_grib_detect_grib_keys 
> _______________
> 
> canonic_da = <xarray.DataArray (time: 4, step: 2, isobaricInhPa: 3, latitude: 
> 5, longitude: 6)>
> array([[[[[0., 0., 0., 0., 0., 0.],...   (latitude) float64 90.0 45.0 0.0 
> -45.0 -90.0
>   * longitude      (longitude) float64 0.0 60.0 120.0 180.0 240.0 300.0
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-5/test_canonical_dataarray_to_gr1')
> 
>     def test_canonical_dataarray_to_grib_detect_grib_keys(canonic_da, tmpdir):
>         out_path = tmpdir.join('res.grib')
>         with open(str(out_path), 'wb') as file:
> >           xarray_to_grib.canonical_dataarray_to_grib(canonic_da, file)
> 
> tests/test_40_xarray_to_grib_regular_ll.py:36: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 12:00:00',
>                '2018-01-02 00:00:00', '2018-01-02 12:00:00'],
>               dtype='datetime64[ns]', name='time', freq=None)
> key = 1514764800000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1514764800000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ________________________ test_canonical_dataset_to_grib 
> ________________________
> 
> canonic_da = <xarray.DataArray (time: 4, step: 2, isobaricInhPa: 3, latitude: 
> 5, longitude: 6)>
> array([[[[[0., 0., 0., 0., 0., 0.],...   (latitude) float64 90.0 45.0 0.0 
> -45.0 -90.0
>   * longitude      (longitude) float64 0.0 60.0 120.0 180.0 240.0 300.0
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-5/test_canonical_dataset_to_grib0')
> 
>     def test_canonical_dataset_to_grib(canonic_da, tmpdir):
>         out_path = tmpdir.join('res.grib')
>         canonic_ds = canonic_da.to_dataset(name='t')
>         with pytest.warns(FutureWarning):
> >           xarray_to_grib.canonical_dataset_to_grib(canonic_ds, 
> > str(out_path))
> 
> tests/test_40_xarray_to_grib_regular_ll.py:51: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 12:00:00',
>                '2018-01-02 00:00:00', '2018-01-02 12:00:00'],
>               dtype='datetime64[ns]', name='time', freq=None)
> key = 1514764800000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1514764800000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> _________________________________ test_to_grib 
> _________________________________
> 
> canonic_da = <xarray.DataArray (time: 4, step: 2, isobaricInhPa: 3, latitude: 
> 5, longitude: 6)>
> array([[[[[0., 0., 0., 0., 0., 0.],...   (latitude) float64 90.0 45.0 0.0 
> -45.0 -90.0
>   * longitude      (longitude) float64 0.0 60.0 120.0 180.0 240.0 300.0
> tmpdir = local('/tmp/pytest-of-user42/pytest-5/test_to_grib0')
> 
>     def test_to_grib(canonic_da, tmpdir):
>         out_path = tmpdir.join('res.grib')
>         canonic_ds = canonic_da.to_dataset(name='t')
>         with pytest.warns(FutureWarning):
> >           xarray_to_grib.to_grib(canonic_ds, str(out_path))
> 
> tests/test_40_xarray_to_grib_regular_ll.py:60: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:269: in to_grib
>     return canonical_dataset_to_grib(*args, **kwargs)
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 12:00:00',
>                '2018-01-02 00:00:00', '2018-01-02 12:00:00'],
>               dtype='datetime64[ns]', name='time', freq=None)
> key = 1514764800000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1514764800000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> _____________ test_canonical_dataset_to_grib[era5-levels-members] 
> ______________
> 
> grib_name = 'era5-levels-members'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-5/test_canonical_dataset_to_grib1')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-01-01 00:00:00', '2017-01-01 12:00:00',
>                '2017-01-02 00:00:00', '2017-01-02 12:00:00'],
>               dtype='datetime64[ns]', name='time', freq=None)
> key = 1483228800000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1483228800000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ------------------------------ Captured log call 
> -------------------------------
> WARNING  cfgrib.messages:messages.py:360 Ignoring index file 
> '/<<PKGBUILDDIR>>/.pybuild/cpython3_3.9_cfgrib/build/tests/sample-data/era5-levels-members.grib.90c91.idx'
>  incompatible with GRIB file
> __________ test_canonical_dataset_to_grib[fields_with_missing_values] 
> __________
> 
> grib_name = 'fields_with_missing_values'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-5/test_canonical_dataset_to_grib2')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-10-18 00:00:00', '2017-10-18 12:00:00'], 
> dtype='datetime64[ns]', name='time', freq=None)
> key = 1508284800000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1508284800000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> __________________ test_canonical_dataset_to_grib[reduced_gg] 
> __________________
> 
> grib_name = 'reduced_gg'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-5/test_canonical_dataset_to_grib4')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-10-18 12:00:00'], dtype='datetime64[ns]', 
> name='time', freq=None)
> key = 1508328000000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1508328000000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ________________ test_canonical_dataset_to_grib[regular_gg_sfc] 
> ________________
> 
> grib_name = 'regular_gg_sfc'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-5/test_canonical_dataset_to_grib5')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-10-18 12:00:00'], dtype='datetime64[ns]', 
> name='time', freq=None)
> key = 1508328000000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1508328000000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ________________ test_canonical_dataset_to_grib[regular_gg_pl] 
> _________________
> 
> grib_name = 'regular_gg_pl'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-5/test_canonical_dataset_to_grib6')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-10-18 12:00:00'], dtype='datetime64[ns]', 
> name='time', freq=None)
> key = 1508328000000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1508328000000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ________________ test_canonical_dataset_to_grib[regular_gg_ml] 
> _________________
> 
> grib_name = 'regular_gg_ml'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-5/test_canonical_dataset_to_grib7')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2008-02-06 12:00:00'], dtype='datetime64[ns]', 
> name='time', freq=None)
> key = 1202299200000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1202299200000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ________________ test_canonical_dataset_to_grib[regular_ll_sfc] 
> ________________
> 
> grib_name = 'regular_ll_sfc'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-5/test_canonical_dataset_to_grib9')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-10-18 12:00:00'], dtype='datetime64[ns]', 
> name='time', freq=None)
> key = 1508328000000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1508328000000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ________________ test_canonical_dataset_to_grib[regular_ll_msl] 
> ________________
> 
> grib_name = 'regular_ll_msl'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-5/test_canonical_dataset_to_grib10')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2006-10-04'], dtype='datetime64[ns]', name='time', 
> freq=None)
> key = 1159920000000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1159920000000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> _______________ test_canonical_dataset_to_grib[scanning_mode_64] 
> _______________
> 
> grib_name = 'scanning_mode_64'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-5/test_canonical_dataset_to_grib11')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-10-18 12:00:00'], dtype='datetime64[ns]', 
> name='time', freq=None)
> key = 1508328000000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1508328000000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> _____________ test_canonical_dataset_to_grib[t_analysis_and_fc_0] 
> ______________
> 
> grib_name = 't_analysis_and_fc_0'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-5/test_canonical_dataset_to_grib13')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-10-18 12:00:00'], dtype='datetime64[ns]', 
> name='time', freq=None)
> key = 1508328000000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1508328000000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> =============================== warnings summary 
> ===============================
> .pybuild/cpython3_3.9_cfgrib/build/tests/test_20_cfcoords.py::test_translate_coords_errors
> .pybuild/cpython3_3.9_cfgrib/build/tests/test_20_cfcoords.py::test_ensure_valid_time
>   /usr/lib/python3/dist-packages/xarray/core/dataarray.py:2090: 
> PendingDeprecationWarning: dropping variables using `drop` will be 
> deprecated; using drop_vars is encouraged.
>     ds = self._to_temp_dataset().drop(labels, dim, errors=errors)
> 
> .pybuild/cpython3_3.9_cfgrib/build/tests/test_20_cfcoords.py::test_ensure_valid_time
> .pybuild/cpython3_3.9_cfgrib/build/tests/test_20_cfcoords.py::test_ensure_valid_time
> .pybuild/cpython3_3.9_cfgrib/build/tests/test_20_cfcoords.py::test_ensure_valid_time
> .pybuild/cpython3_3.9_cfgrib/build/tests/test_20_cfcoords.py::test_ensure_valid_time
> .pybuild/cpython3_3.9_cfgrib/build/tests/test_20_cfcoords.py::test_ensure_valid_time
> .pybuild/cpython3_3.9_cfgrib/build/tests/test_20_cfcoords.py::test_ensure_valid_time
>   /<<PKGBUILDDIR>>/.pybuild/cpython3_3.9_cfgrib/build/cf2cdm/cfcoords.py:233: 
> DeprecationWarning: ensure_valid_time is deprecated use time_dims instead
>     warnings.warn("ensure_valid_time is deprecated use time_dims instead", 
> DeprecationWarning)
> 
> -- Docs: https://docs.pytest.org/en/latest/warnings.html
> === 14 failed, 105 passed, 1 skipped, 3 xfailed, 8 warnings in 18.33 seconds 
> ===
> E: pybuild pybuild:352: test: plugin distutils failed with: exit code=1: cd 
> /<<PKGBUILDDIR>>/.pybuild/cpython3_3.9_cfgrib/build; python3.9 -m pytest tests
> I: pybuild base:217: cd /<<PKGBUILDDIR>>/.pybuild/cpython3_3.8_cfgrib/build; 
> python3.8 -m pytest tests
> ============================= test session starts 
> ==============================
> platform linux -- Python 3.8.6, pytest-4.6.11, py-1.9.0, pluggy-0.13.0
> rootdir: /<<PKGBUILDDIR>>, inifile: setup.cfg
> collected 122 items / 1 skipped / 121 selected
> 
> tests/test_10_bindings.py ........................                       [ 
> 19%]
> tests/test_10_cfunits.py .                                               [ 
> 20%]
> tests/test_20_cfcoords.py ......                                         [ 
> 25%]
> tests/test_20_main.py .                                                  [ 
> 26%]
> tests/test_20_messages.py .........                                      [ 
> 33%]
> tests/test_25_cfmessage.py .....                                         [ 
> 37%]
> tests/test_30_dataset.py ...................                             [ 
> 53%]
> tests/test_40_xarray_store.py .......                                    [ 
> 59%]
> tests/test_40_xarray_to_grib_regular_ll.py FF.FF                         [ 
> 63%]
> tests/test_50_datamodels.py ..                                           [ 
> 64%]
> tests/test_50_sample_data.py ....................FFxFFFFxFFFxF           [ 
> 91%]
> tests/test_50_xarray_getitem.py ..........                               
> [100%]
> 
> =================================== FAILURES 
> ===================================
> _______________ test_canonical_dataarray_to_grib_with_grib_keys 
> ________________
> 
> canonic_da = <xarray.DataArray (time: 4, step: 2, isobaricInhPa: 3, latitude: 
> 5, longitude: 6)>
> array([[[[[0., 0., 0., 0., 0., 0.],...   (latitude) float64 90.0 45.0 0.0 
> -45.0 -90.0
>   * longitude      (longitude) float64 0.0 60.0 120.0 180.0 240.0 300.0
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-6/test_canonical_dataarray_to_gr0')
> 
>     def test_canonical_dataarray_to_grib_with_grib_keys(canonic_da, tmpdir):
>         out_path = tmpdir.join('res.grib')
>         grib_keys = {'gridType': 'regular_ll'}
>         with open(str(out_path), 'wb') as file:
> >           xarray_to_grib.canonical_dataarray_to_grib(canonic_da, file, 
> > grib_keys=grib_keys)
> 
> tests/test_40_xarray_to_grib_regular_ll.py:30: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 12:00:00',
>                '2018-01-02 00:00:00', '2018-01-02 12:00:00'],
>               dtype='datetime64[ns]', name='time', freq=None)
> key = 1514764800000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1514764800000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ______________ test_canonical_dataarray_to_grib_detect_grib_keys 
> _______________
> 
> canonic_da = <xarray.DataArray (time: 4, step: 2, isobaricInhPa: 3, latitude: 
> 5, longitude: 6)>
> array([[[[[0., 0., 0., 0., 0., 0.],...   (latitude) float64 90.0 45.0 0.0 
> -45.0 -90.0
>   * longitude      (longitude) float64 0.0 60.0 120.0 180.0 240.0 300.0
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-6/test_canonical_dataarray_to_gr1')
> 
>     def test_canonical_dataarray_to_grib_detect_grib_keys(canonic_da, tmpdir):
>         out_path = tmpdir.join('res.grib')
>         with open(str(out_path), 'wb') as file:
> >           xarray_to_grib.canonical_dataarray_to_grib(canonic_da, file)
> 
> tests/test_40_xarray_to_grib_regular_ll.py:36: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 12:00:00',
>                '2018-01-02 00:00:00', '2018-01-02 12:00:00'],
>               dtype='datetime64[ns]', name='time', freq=None)
> key = 1514764800000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1514764800000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ________________________ test_canonical_dataset_to_grib 
> ________________________
> 
> canonic_da = <xarray.DataArray (time: 4, step: 2, isobaricInhPa: 3, latitude: 
> 5, longitude: 6)>
> array([[[[[0., 0., 0., 0., 0., 0.],...   (latitude) float64 90.0 45.0 0.0 
> -45.0 -90.0
>   * longitude      (longitude) float64 0.0 60.0 120.0 180.0 240.0 300.0
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-6/test_canonical_dataset_to_grib0')
> 
>     def test_canonical_dataset_to_grib(canonic_da, tmpdir):
>         out_path = tmpdir.join('res.grib')
>         canonic_ds = canonic_da.to_dataset(name='t')
>         with pytest.warns(FutureWarning):
> >           xarray_to_grib.canonical_dataset_to_grib(canonic_ds, 
> > str(out_path))
> 
> tests/test_40_xarray_to_grib_regular_ll.py:51: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 12:00:00',
>                '2018-01-02 00:00:00', '2018-01-02 12:00:00'],
>               dtype='datetime64[ns]', name='time', freq=None)
> key = 1514764800000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1514764800000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> _________________________________ test_to_grib 
> _________________________________
> 
> canonic_da = <xarray.DataArray (time: 4, step: 2, isobaricInhPa: 3, latitude: 
> 5, longitude: 6)>
> array([[[[[0., 0., 0., 0., 0., 0.],...   (latitude) float64 90.0 45.0 0.0 
> -45.0 -90.0
>   * longitude      (longitude) float64 0.0 60.0 120.0 180.0 240.0 300.0
> tmpdir = local('/tmp/pytest-of-user42/pytest-6/test_to_grib0')
> 
>     def test_to_grib(canonic_da, tmpdir):
>         out_path = tmpdir.join('res.grib')
>         canonic_ds = canonic_da.to_dataset(name='t')
>         with pytest.warns(FutureWarning):
> >           xarray_to_grib.to_grib(canonic_ds, str(out_path))
> 
> tests/test_40_xarray_to_grib_regular_ll.py:60: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:269: in to_grib
>     return canonical_dataset_to_grib(*args, **kwargs)
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 12:00:00',
>                '2018-01-02 00:00:00', '2018-01-02 12:00:00'],
>               dtype='datetime64[ns]', name='time', freq=None)
> key = 1514764800000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1514764800000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> _____________ test_canonical_dataset_to_grib[era5-levels-members] 
> ______________
> 
> grib_name = 'era5-levels-members'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-6/test_canonical_dataset_to_grib1')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-01-01 00:00:00', '2017-01-01 12:00:00',
>                '2017-01-02 00:00:00', '2017-01-02 12:00:00'],
>               dtype='datetime64[ns]', name='time', freq=None)
> key = 1483228800000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1483228800000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ------------------------------ Captured log call 
> -------------------------------
> WARNING  cfgrib.messages:messages.py:360 Ignoring index file 
> '/<<PKGBUILDDIR>>/.pybuild/cpython3_3.8_cfgrib/build/tests/sample-data/era5-levels-members.grib.90c91.idx'
>  incompatible with GRIB file
> __________ test_canonical_dataset_to_grib[fields_with_missing_values] 
> __________
> 
> grib_name = 'fields_with_missing_values'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-6/test_canonical_dataset_to_grib2')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-10-18 00:00:00', '2017-10-18 12:00:00'], 
> dtype='datetime64[ns]', name='time', freq=None)
> key = 1508284800000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1508284800000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> __________________ test_canonical_dataset_to_grib[reduced_gg] 
> __________________
> 
> grib_name = 'reduced_gg'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-6/test_canonical_dataset_to_grib4')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-10-18 12:00:00'], dtype='datetime64[ns]', 
> name='time', freq=None)
> key = 1508328000000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1508328000000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ________________ test_canonical_dataset_to_grib[regular_gg_sfc] 
> ________________
> 
> grib_name = 'regular_gg_sfc'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-6/test_canonical_dataset_to_grib5')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-10-18 12:00:00'], dtype='datetime64[ns]', 
> name='time', freq=None)
> key = 1508328000000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1508328000000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ________________ test_canonical_dataset_to_grib[regular_gg_pl] 
> _________________
> 
> grib_name = 'regular_gg_pl'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-6/test_canonical_dataset_to_grib6')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-10-18 12:00:00'], dtype='datetime64[ns]', 
> name='time', freq=None)
> key = 1508328000000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1508328000000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ________________ test_canonical_dataset_to_grib[regular_gg_ml] 
> _________________
> 
> grib_name = 'regular_gg_ml'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-6/test_canonical_dataset_to_grib7')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2008-02-06 12:00:00'], dtype='datetime64[ns]', 
> name='time', freq=None)
> key = 1202299200000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1202299200000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ________________ test_canonical_dataset_to_grib[regular_ll_sfc] 
> ________________
> 
> grib_name = 'regular_ll_sfc'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-6/test_canonical_dataset_to_grib9')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-10-18 12:00:00'], dtype='datetime64[ns]', 
> name='time', freq=None)
> key = 1508328000000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1508328000000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> ________________ test_canonical_dataset_to_grib[regular_ll_msl] 
> ________________
> 
> grib_name = 'regular_ll_msl'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-6/test_canonical_dataset_to_grib10')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2006-10-04'], dtype='datetime64[ns]', name='time', 
> freq=None)
> key = 1159920000000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1159920000000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> _______________ test_canonical_dataset_to_grib[scanning_mode_64] 
> _______________
> 
> grib_name = 'scanning_mode_64'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-6/test_canonical_dataset_to_grib11')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-10-18 12:00:00'], dtype='datetime64[ns]', 
> name='time', freq=None)
> key = 1508328000000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1508328000000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> _____________ test_canonical_dataset_to_grib[t_analysis_and_fc_0] 
> ______________
> 
> grib_name = 't_analysis_and_fc_0'
> tmpdir = 
> local('/tmp/pytest-of-user42/pytest-6/test_canonical_dataset_to_grib13')
> 
>     @pytest.mark.parametrize(
>         'grib_name',
>         [
>             'era5-levels-members',
>             'fields_with_missing_values',
>             pytest.param('lambert_grid', marks=pytest.mark.xfail),
>             'reduced_gg',
>             'regular_gg_sfc',
>             'regular_gg_pl',
>             'regular_gg_ml',
>             pytest.param('regular_gg_ml_g2', marks=pytest.mark.xfail),
>             'regular_ll_sfc',
>             'regular_ll_msl',
>             'scanning_mode_64',
>             pytest.param('spherical_harmonics', marks=pytest.mark.xfail),
>             't_analysis_and_fc_0',
>         ],
>     )
>     def test_canonical_dataset_to_grib(grib_name, tmpdir):
>         grib_path = os.path.join(SAMPLE_DATA_FOLDER, grib_name + '.grib')
>         out_path = str(tmpdir.join(grib_name + '.grib'))
>     
>         res = xarray_store.open_dataset(grib_path)
>     
> >       xarray_to_grib.canonical_dataset_to_grib(res, out_path)
> 
> tests/test_50_sample_data.py:89: 
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> cfgrib/xarray_to_grib.py:265: in canonical_dataset_to_grib
>     canonical_dataarray_to_grib(data_var, file, grib_keys=real_grib_keys, 
> **kwargs)
> cfgrib/xarray_to_grib.py:224: in canonical_dataarray_to_grib
>     field_values = data_var.sel(**select).values.flat[:]
> /usr/lib/python3/dist-packages/xarray/core/dataarray.py:1143: in sel
>     ds = self._to_temp_dataset().sel(
> /usr/lib/python3/dist-packages/xarray/core/dataset.py:2105: in sel
>     pos_indexers, new_indexes = remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/coordinates.py:397: in 
> remap_label_indexers
>     pos_indexers, new_indexes = indexing.remap_label_indexers(
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:275: in 
> remap_label_indexers
>     idxr, new_idx = convert_label_indexer(index, label, dim, method, 
> tolerance)
> /usr/lib/python3/dist-packages/xarray/core/indexing.py:196: in 
> convert_label_indexer
>     indexer = index.get_loc(label_value, method=method, tolerance=tolerance)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
> _ 
> 
> self = DatetimeIndex(['2017-10-18 12:00:00'], dtype='datetime64[ns]', 
> name='time', freq=None)
> key = 1508328000000000000, method = None, tolerance = None
> 
>     def get_loc(self, key, method=None, tolerance=None):
>         """
>         Get integer location for requested label
>     
>         Returns
>         -------
>         loc : int
>         """
>         if not is_scalar(key):
>             raise InvalidIndexError(key)
>     
>         orig_key = key
>         if is_valid_nat_for_dtype(key, self.dtype):
>             key = NaT
>     
>         if isinstance(key, self._data._recognized_scalars):
>             # needed to localize naive datetimes
>             key = self._maybe_cast_for_get_loc(key)
>     
>         elif isinstance(key, str):
>             try:
>                 return self._get_string_slice(key)
>             except (TypeError, KeyError, ValueError, OverflowError):
>                 pass
>     
>             try:
>                 key = self._maybe_cast_for_get_loc(key)
>             except ValueError as err:
>                 raise KeyError(key) from err
>     
>         elif isinstance(key, timedelta):
>             # GH#20464
>             raise TypeError(
>                 f"Cannot index {type(self).__name__} with 
> {type(key).__name__}"
>             )
>     
>         elif isinstance(key, time):
>             if method is not None:
>                 raise NotImplementedError(
>                     "cannot yet lookup inexact labels when key is a time 
> object"
>                 )
>             return self.indexer_at_time(key)
>     
>         else:
>             # unrecognized type
> >           raise KeyError(key)
> E           KeyError: 1508328000000000000
> 
> /usr/lib/python3/dist-packages/pandas/core/indexes/datetimes.py:622: KeyError
> =============================== warnings summary 
> ===============================
> .pybuild/cpython3_3.8_cfgrib/build/tests/test_20_cfcoords.py::test_translate_coords_errors
> .pybuild/cpython3_3.8_cfgrib/build/tests/test_20_cfcoords.py::test_ensure_valid_time
>   /usr/lib/python3/dist-packages/xarray/core/dataarray.py:2090: 
> PendingDeprecationWarning: dropping variables using `drop` will be 
> deprecated; using drop_vars is encouraged.
>     ds = self._to_temp_dataset().drop(labels, dim, errors=errors)
> 
> .pybuild/cpython3_3.8_cfgrib/build/tests/test_20_cfcoords.py::test_ensure_valid_time
> .pybuild/cpython3_3.8_cfgrib/build/tests/test_20_cfcoords.py::test_ensure_valid_time
> .pybuild/cpython3_3.8_cfgrib/build/tests/test_20_cfcoords.py::test_ensure_valid_time
> .pybuild/cpython3_3.8_cfgrib/build/tests/test_20_cfcoords.py::test_ensure_valid_time
> .pybuild/cpython3_3.8_cfgrib/build/tests/test_20_cfcoords.py::test_ensure_valid_time
> .pybuild/cpython3_3.8_cfgrib/build/tests/test_20_cfcoords.py::test_ensure_valid_time
>   /<<PKGBUILDDIR>>/.pybuild/cpython3_3.8_cfgrib/build/cf2cdm/cfcoords.py:233: 
> DeprecationWarning: ensure_valid_time is deprecated use time_dims instead
>     warnings.warn("ensure_valid_time is deprecated use time_dims instead", 
> DeprecationWarning)
> 
> -- Docs: https://docs.pytest.org/en/latest/warnings.html
> === 14 failed, 105 passed, 1 skipped, 3 xfailed, 8 warnings in 18.27 seconds 
> ===
> E: pybuild pybuild:352: test: plugin distutils failed with: exit code=1: cd 
> /<<PKGBUILDDIR>>/.pybuild/cpython3_3.8_cfgrib/build; python3.8 -m pytest tests
> make[1]: *** [debian/rules:19: override_dh_auto_test] Error 13

The full build log is available from:
   http://qa-logs.debian.net/2020/10/27/cfgrib_0.9.8.4-1_unstable.log

A list of current common problems and possible solutions is available at
http://wiki.debian.org/qa.debian.org/FTBFS . You're welcome to contribute!

About the archive rebuild: The rebuild was done on EC2 VM instances from
Amazon Web Services, using a clean, minimal and up-to-date chroot. Every
failed build was retried once to eliminate random failures.

--- End Message ---

--- Begin Message ---

Source: cfgrib
Source-Version: 0.9.8.4-2
Done: Alastair McKinstry <mckins...@debian.org>

We believe that the bug you reported is fixed in the latest version of
cfgrib, which is due to be installed in the Debian FTP archive.

A summary of the changes between this version and the previous one is
attached.

Thank you for reporting the bug, which will now be closed.  If you
have further comments please address them to 973...@bugs.debian.org,
and the maintainer will reopen the bug report if appropriate.

Debian distribution maintenance software
pp.
Alastair McKinstry <mckins...@debian.org> (supplier of updated cfgrib package)

(This message was generated automatically at their request; if you
believe that there is a problem with it please contact the archive
administrators by mailing ftpmas...@ftp-master.debian.org)


-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA256

Format: 1.8
Date: Tue, 10 Nov 2020 14:46:49 +0000
Source: cfgrib
Architecture: source
Version: 0.9.8.4-2
Distribution: unstable
Urgency: medium
Maintainer: Alastair McKinstry <mckins...@debian.org>
Changed-By: Alastair McKinstry <mckins...@debian.org>
Closes: 971455 973115
Changes:
 cfgrib (0.9.8.4-2) unstable; urgency=medium
 .
   * Add additional autopkg tests. Closes: #971455
   * Disable via XFAIL tests that fail due to Pandas (see #973819).
     Closes: #973115.
Checksums-Sha1:
 2753bbcd22864e418e218acf82ac10b3760ba4d7 2082 cfgrib_0.9.8.4-2.dsc
 804e5edb7f6d9d08c2190d83c536983cd4befb52 8020 cfgrib_0.9.8.4-2.debian.tar.xz
Checksums-Sha256:
 d085f80cce68166389c7c0fd4ef94949f60b646c97df66608aa3b6b2a3bdd3fd 2082 
cfgrib_0.9.8.4-2.dsc
 bdd2bf95869530f7d2c0647dc7afcffd1eac6596c48b91a205cb77ecf55bf430 8020 
cfgrib_0.9.8.4-2.debian.tar.xz
Files:
 744842d012c214d884f7f4a8857381e8 2082 python optional cfgrib_0.9.8.4-2.dsc
 312945e50bb6d7fca2ff1be15b43ed6a 8020 python optional 
cfgrib_0.9.8.4-2.debian.tar.xz

-----BEGIN PGP SIGNATURE-----

iQIzBAEBCAAdFiEEgjg86RZbNHx4cIGiy+a7Tl2a06UFAl+qqwMACgkQy+a7Tl2a
06XhgA/7BZkgMfA7HcFezk+Z/mCP5e7gxSh5Xpssk1OHdt9zCSDBC5j4Ivq5otvb
gVXplRavEVIf4gMMo8AsUc/JVL2G/k7E5AL6T2+K68QpTuQLq6xDVaNAEI7tgk72
Ke7k0857doNGgnS9bkP87qmQQWzzMhix1jzNqxu7jpGAydbaht31bvURBTNMhxdO
/4m9+idcpjXmBAot8VanEOVZtaQ4ofq2bQjDBdmGvNqGYbv1vaYy8WklVVDBL4hR
d5AbiPb5A3jV3ETK2YeXiy88RbAoiuLG9atXEHtELtm42B3AgMEc5e+gyxdZp42N
glwqIvcXhpSzM8hwTKs7k0FiWWuT+5sCeBMFYIS3I4s4iw2MMDS5NiIwJZJXMVh5
thBx2Rz/K+z7gF3VDBJBb53ktJkOsdx/KnC+as6jQrGUwEA90v3veK4fM1jAJiNI
aXHR1oxv0CnJE5u1z6BALttIjuUM7EzMpLBcq0CiaKivrdzNdHD4+DV7MZllfJcH
dChyuD67hdKV0HLjLcjRkvQPfK0UNgOpXX0+te10S/s8cimb+lboIiVxb5w690g+
m4oR+l580L/gqMba+D0pgrl/8SgxVIS4I+KYe5vsO9mVu0Bp2X2KFn0dIHIwaMjE
c+MtyJtZw6eN7YEUDNCtGi9R5CBeL2g4jhRhdHvqAsair80m7h0=
=17lM
-----END PGP SIGNATURE-----

--- End Message ---