Bug#973821: marked as done (pandas 1.13.1: regression in datetime handling causes test failures in cfgrib)

[Debian Bug Tracking System]

Your message dated Tue, 14 Dec 2021 16:03:32 +0000
with message-id <e1mxah6-000eit...@fasolo.debian.org>
and subject line Bug#973821: fixed in cfgrib 0.9.9.1-2
has caused the Debian Bug report #973821,
regarding pandas 1.13.1: regression in datetime handling causes test failures 
in cfgrib
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.)


-- 
973821: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=973821
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.9.1-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, 14 Dec 2021 15:37:37 +0000
Source: cfgrib
Architecture: source
Version: 0.9.9.1-2
Distribution: unstable
Urgency: medium
Maintainer: Alastair McKinstry <mckins...@debian.org>
Changed-By: Alastair McKinstry <mckins...@debian.org>
Closes: 973821 1000726
Changes:
 cfgrib (0.9.9.1-2) unstable; urgency=medium
 .
   * Fix for pandas > 1.3. Closes: #973821, #1000726
Checksums-Sha1:
 e2a043f11a44d21ab69d2e832272cb3b14aaafb8 2116 cfgrib_0.9.9.1-2.dsc
 80e24479430262fb06bf9aba2d6d680c701b5908 8552 cfgrib_0.9.9.1-2.debian.tar.xz
Checksums-Sha256:
 4c6a0b34b36715889a6b617647202f85a27d86a885f15a84baad18f8928f00a8 2116 
cfgrib_0.9.9.1-2.dsc
 11beff4b19f57eb8c470d51164d1e7d278cedd1f3eb6c88d89c547634e95ec64 8552 
cfgrib_0.9.9.1-2.debian.tar.xz
Files:
 d7895f5aabb834dea52d2a777166f16d 2116 python optional cfgrib_0.9.9.1-2.dsc
 6c46663ff2abc763409470d17a5bee6c 8552 python optional 
cfgrib_0.9.9.1-2.debian.tar.xz

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

iQIzBAEBCAAdFiEEgjg86RZbNHx4cIGiy+a7Tl2a06UFAmG4vHkACgkQy+a7Tl2a
06X9Wg//cq1JcehlkOkXfkh+9VZqGpIxwKHEpFHYr0Po2GM7FhvgSZK4JvMSfYap
X9GU7b6MrWUAdabSv8RLTYyGuXV7PXvdAMXGpAfckWLT7dxqYrz0DY9ZEi+QgXrF
DFsC/ep9ol+XIwCZx5HbXtZkRKbFAPylxneVadO36NwucqfX2cJqU9Ksffe4rtUd
N1oc72Ca2o3pWA74oMLwDN2u65w1MTTpBYFsIqGYN63gMJBDkPsOrycs26t3me79
erSfuyAb7E38duqpJmlcek8PG4ahynAAteXtfkJmX3CBSppYFQJ+n73swe0qaRxx
4JL2Ecp5W1MDb1lVQGhRFqaCX1q0YzZ50CnTKbKKSHk6eYHWOz9rS8qIrEGno4WV
A3V2GGjzbUUTCryHMKIgsc3fWxSoZQE4cS7Q9iGMJ+BQPH4NwCJfIolQeAli63X0
afXUOzZDYm0kUIudE21oOdC4mFNmZSjq1LxvkC+qG/5GoOyLP84rmcil3YkDOCOy
RYvuCDDdwieOMFLjbxBdk0uSmDC8MT6Rq5QhDLKEnPjr/24tMC2UvuQesV+e78rF
v/7aaEezaa9GwaVcsqOFciGz6Y7Xyxbe+GaRVVRw961BumPPvaarVNPwt3xlotRA
43OEhWdlb3qNuG3tmX69ZiHRCxBWH1V6h2POycQHhRcTARswXRs=
=XGeD
-----END PGP SIGNATURE-----

--- End Message ---

-- 
debian-science-maintainers mailing list
debian-science-maintainers@alioth-lists.debian.net
https://alioth-lists.debian.net/cgi-bin/mailman/listinfo/debian-science-maintainers