def test_dataset_repr_with_netcdf4_datetimes(self):
        # regression test for #347
        attrs = {'units': 'days since 0001-01-01', 'calendar': 'noleap'}
        with warnings.catch_warnings():
            warnings.filterwarnings('ignore', 'unable to decode time')
            ds = decode_cf(Dataset({'time': ('time', [0, 1], attrs)}))
            assert '(time) object' in repr(ds)

        attrs = {'units': 'days since 1900-01-01'}
        ds = decode_cf(Dataset({'time': ('time', [0, 1], attrs)}))
        assert '(time) datetime64[ns]' in repr(ds)

 def test_decode_cf_with_dask(self):
     import dask.array as da
     original = Dataset({
         't': ('t', [0, 1, 2], {'units': 'days since 2000-01-01'}),
         'foo': ('t', [0, 0, 0], {'coordinates': 'y', 'units': 'bar'}),
         'bar': ('string2', [b'a', b'b']),
         'baz': (('x'), [b'abc'], {'_Encoding': 'utf-8'}),
         'y': ('t', [5, 10, -999], {'_FillValue': -999})
     }).chunk()
     decoded = conventions.decode_cf(original)
     print(decoded)
     assert all(isinstance(var.data, da.Array)
                for name, var in decoded.variables.items()
                if name not in decoded.indexes)
     assert_identical(decoded, conventions.decode_cf(original).compute())

 def test_multidimensional_coordinates(self):
     # regression test for GH1763
     # Set up test case with coordinates that have overlapping (but not
     # identical) dimensions.
     zeros1 = np.zeros((1, 5, 3))
     zeros2 = np.zeros((1, 6, 3))
     zeros3 = np.zeros((1, 5, 4))
     orig = Dataset({
         'lon1': (['x1', 'y1'], zeros1.squeeze(0), {}),
         'lon2': (['x2', 'y1'], zeros2.squeeze(0), {}),
         'lon3': (['x1', 'y2'], zeros3.squeeze(0), {}),
         'lat1': (['x1', 'y1'], zeros1.squeeze(0), {}),
         'lat2': (['x2', 'y1'], zeros2.squeeze(0), {}),
         'lat3': (['x1', 'y2'], zeros3.squeeze(0), {}),
         'foo1': (['time', 'x1', 'y1'], zeros1,
                  {'coordinates': 'lon1 lat1'}),
         'foo2': (['time', 'x2', 'y1'], zeros2,
                  {'coordinates': 'lon2 lat2'}),
         'foo3': (['time', 'x1', 'y2'], zeros3,
                  {'coordinates': 'lon3 lat3'}),
         'time': ('time', [0.], {'units': 'hours since 2017-01-01'}),
     })
     orig = conventions.decode_cf(orig)
     # Encode the coordinates, as they would be in a netCDF output file.
     enc, attrs = conventions.encode_dataset_coordinates(orig)
     # Make sure we have the right coordinates for each variable.
     foo1_coords = enc['foo1'].attrs.get('coordinates', '')
     foo2_coords = enc['foo2'].attrs.get('coordinates', '')
     foo3_coords = enc['foo3'].attrs.get('coordinates', '')
     assert set(foo1_coords.split()) == set(['lat1', 'lon1'])
     assert set(foo2_coords.split()) == set(['lat2', 'lon2'])
     assert set(foo3_coords.split()) == set(['lat3', 'lon3'])
     # Should not have any global coordinates.
     assert 'coordinates' not in attrs

 def test_decode_cf_with_drop_variables(self):
     original = Dataset({
         't': ('t', [0, 1, 2], {'units': 'days since 2000-01-01'}),
         'x': ("x", [9, 8, 7], {'units': 'km'}),
         'foo': (('t', 'x'), [[0, 0, 0], [1, 1, 1], [2, 2, 2]], {'units': 'bar'}),
         'y': ('t', [5, 10, -999], {'_FillValue': -999})
     })
     expected = Dataset({
         't': pd.date_range('2000-01-01', periods=3),
         'foo': (('t', 'x'), [[0, 0, 0], [1, 1, 1], [2, 2, 2]], {'units': 'bar'}),
         'y': ('t', [5, 10, np.nan])
     })
     actual = conventions.decode_cf(original, drop_variables=("x",))
     actual2 = conventions.decode_cf(original, drop_variables="x")
     self.assertDatasetIdentical(expected, actual)
     self.assertDatasetIdentical(expected, actual2)

    def test_dataset_repr_with_netcdf4_datetimes(self):
        # regression test for #347
        attrs = {'units': 'days since 0001-01-01', 'calendar': 'noleap'}
        with warnings.catch_warnings():
            warnings.filterwarnings('ignore', 'unable to decode time')
            ds = decode_cf(Dataset({'time': ('time', [0, 1], attrs)}))
            self.assertIn('(time) object', repr(ds))

        attrs = {'units': 'days since 1900-01-01'}
        ds = decode_cf(Dataset({'time': ('time', [0, 1], attrs)}))
        self.assertIn('(time) datetime64[ns]', repr(ds))

        # this should not throw a warning (GH1111)
        with warnings.catch_warnings():
            warnings.filterwarnings('error')
            conventions.DecodedCFDatetimeArray(np.asarray([722624]),
                                               "days since 0001-01-01")

 def test_dataset(self):
     original = Dataset({
         't': ('t', [0, 1, 2], {'units': 'days since 2000-01-01'}),
         'foo': ('t', [0, 0, 0], {'coordinates': 'y', 'units': 'bar'}),
         'y': ('t', [5, 10, -999], {'_FillValue': -999})
     })
     expected = Dataset({'foo': ('t', [0, 0, 0], {'units': 'bar'})},
                        {'t': pd.date_range('2000-01-01', periods=3),
                         'y': ('t', [5.0, 10.0, np.nan])})
     actual = conventions.decode_cf(original)
     assert_identical(expected, actual)

    def test_decode_cf_datetime_transition_to_invalid(self):
        # manually create dataset with not-decoded date
        from datetime import datetime
        ds = Dataset(coords={'time' : [0, 266 * 365]})
        units = 'days since 2000-01-01 00:00:00'
        ds.time.attrs = dict(units=units)
        ds_decoded = conventions.decode_cf(ds)

        expected = [datetime(2000, 1, 1, 0, 0),
                    datetime(2265, 10, 28, 0, 0)]

        self.assertArrayEqual(ds_decoded.time.values, expected)

    def test_decode_cf_datetime_transition_to_invalid(self):
        # manually create dataset with not-decoded date
        from datetime import datetime
        ds = Dataset(coords={'time': [0, 266 * 365]})
        units = 'days since 2000-01-01 00:00:00'
        ds.time.attrs = dict(units=units)
        with warnings.catch_warnings():
            warnings.filterwarnings('ignore', 'unable to decode time')
            ds_decoded = conventions.decode_cf(ds)

        expected = [datetime(2000, 1, 1, 0, 0),
                    datetime(2265, 10, 28, 0, 0)]

        assert_array_equal(ds_decoded.time.values, expected)

 def test_invalid_time_units_raises_eagerly(self):
     ds = Dataset({'time': ('time', [0, 1], {'units': 'foobar since 123'})})
     with raises_regex(ValueError, 'unable to decode time'):
         decode_cf(ds)

 def test_decode_coordinates(self):
     # regression test for GH610
     original = Dataset({'foo': ('t', [1, 2], {'coordinates': 'x'}),
                         'x': ('t', [4, 5])})
     actual = conventions.decode_cf(original)
     assert actual.foo.encoding['coordinates'] == 'x'

 def test_invalid_coordinates(self):
     # regression test for GH308
     original = Dataset({'foo': ('t', [1, 2], {'coordinates': 'invalid'})})
     actual = conventions.decode_cf(original)
     assert_identical(original, actual)