示例#1
0
def test_decode_cf_with_conflicting_fill_missing_value() -> None:
    expected = Variable(["t"], [np.nan, np.nan, 2], {"units": "foobar"})
    var = Variable(
        ["t"], np.arange(3), {"units": "foobar", "missing_value": 0, "_FillValue": 1}
    )
    with warnings.catch_warnings(record=True) as w:
        actual = conventions.decode_cf_variable("t", var)
        assert_identical(actual, expected)
        assert "has multiple fill" in str(w[0].message)

    expected = Variable(["t"], np.arange(10), {"units": "foobar"})

    var = Variable(
        ["t"],
        np.arange(10),
        {"units": "foobar", "missing_value": np.nan, "_FillValue": np.nan},
    )
    actual = conventions.decode_cf_variable("t", var)
    assert_identical(actual, expected)

    var = Variable(
        ["t"],
        np.arange(10),
        {
            "units": "foobar",
            "missing_value": np.float32(np.nan),
            "_FillValue": np.float32(np.nan),
        },
    )
    actual = conventions.decode_cf_variable("t", var)
    assert_identical(actual, expected)
示例#2
0
def test_decode_cf_with_conflicting_fill_missing_value():
    expected = Variable(['t'], [np.nan, np.nan, 2], {'units': 'foobar'})
    var = Variable(['t'], np.arange(3), {
        'units': 'foobar',
        'missing_value': 0,
        '_FillValue': 1
    })
    with warnings.catch_warnings(record=True) as w:
        actual = conventions.decode_cf_variable('t', var)
        assert_identical(actual, expected)
        assert 'has multiple fill' in str(w[0].message)

    expected = Variable(['t'], np.arange(10), {'units': 'foobar'})

    var = Variable(['t'], np.arange(10), {
        'units': 'foobar',
        'missing_value': np.nan,
        '_FillValue': np.nan
    })
    actual = conventions.decode_cf_variable('t', var)
    assert_identical(actual, expected)

    var = Variable(
        ['t'], np.arange(10), {
            'units': 'foobar',
            'missing_value': np.float32(np.nan),
            '_FillValue': np.float32(np.nan)
        })
    actual = conventions.decode_cf_variable('t', var)
    assert_identical(actual, expected)
示例#3
0
def test_decode_cf_with_conflicting_fill_missing_value():
    var = Variable(['t'], np.arange(10), {
        'units': 'foobar',
        'missing_value': 0,
        '_FillValue': 1
    })
    with raises_regex(ValueError, "_FillValue and missing_value"):
        conventions.decode_cf_variable('t', var)

    expected = Variable(['t'], np.arange(10), {'units': 'foobar'})

    var = Variable(['t'], np.arange(10), {
        'units': 'foobar',
        'missing_value': np.nan,
        '_FillValue': np.nan
    })
    actual = conventions.decode_cf_variable('t', var)
    assert_identical(actual, expected)

    var = Variable(
        ['t'], np.arange(10), {
            'units': 'foobar',
            'missing_value': np.float32(np.nan),
            '_FillValue': np.float32(np.nan)
        })
    actual = conventions.decode_cf_variable('t', var)
    assert_identical(actual, expected)
示例#4
0
def test_decode_cf_with_conflicting_fill_missing_value():
    expected = Variable(['t'], [np.nan, np.nan, 2], {'units': 'foobar'})
    var = Variable(['t'], np.arange(3),
                   {'units': 'foobar',
                    'missing_value': 0,
                    '_FillValue': 1})
    with warnings.catch_warnings(record=True) as w:
        actual = conventions.decode_cf_variable('t', var)
        assert_identical(actual, expected)
        assert 'has multiple fill' in str(w[0].message)

    expected = Variable(['t'], np.arange(10), {'units': 'foobar'})

    var = Variable(['t'], np.arange(10),
                   {'units': 'foobar',
                    'missing_value': np.nan,
                    '_FillValue': np.nan})
    actual = conventions.decode_cf_variable('t', var)
    assert_identical(actual, expected)

    var = Variable(['t'], np.arange(10),
                   {'units': 'foobar',
                    'missing_value': np.float32(np.nan),
                    '_FillValue': np.float32(np.nan)})
    actual = conventions.decode_cf_variable('t', var)
    assert_identical(actual, expected)
示例#5
0
    def test_decode_cf_with_conflicting_fill_missing_value(self):
        var = Variable(['t'], np.arange(10), {
            'units': 'foobar',
            'missing_value': 0,
            '_FillValue': 1
        })
        self.assertRaisesRegexp(ValueError, "_FillValue and missing_value",
                                lambda: conventions.decode_cf_variable(var))

        var = Variable(['t'], np.arange(10), {
            'units': 'foobar',
            'missing_value': np.nan,
            '_FillValue': np.nan
        })
        var = conventions.decode_cf_variable(var)
        self.assertIsNotNone(var)

        var = Variable(
            ['t'], np.arange(10), {
                'units': 'foobar',
                'missing_value': np.float32(np.nan),
                '_FillValue': np.float32(np.nan)
            })
        var = conventions.decode_cf_variable(var)
        self.assertIsNotNone(var)
示例#6
0
 def test_decode_cf_with_multiple_missing_values(self) -> None:
     original = Variable(["t"], [0, 1, 2], {"missing_value": np.array([0, 1])})
     expected = Variable(["t"], [np.nan, np.nan, 2], {})
     with warnings.catch_warnings(record=True) as w:
         actual = conventions.decode_cf_variable("t", original)
         assert_identical(expected, actual)
         assert "has multiple fill" in str(w[0].message)
示例#7
0
 def test_decode_cf_with_conflicting_fill_missing_value(self):
     var = Variable(['t'], np.arange(10),
                    {'units': 'foobar',
                     'missing_value': 0,
                     '_FillValue': 1})
     self.assertRaisesRegexp(ValueError, "_FillValue and missing_value",
                             lambda: conventions.decode_cf_variable(var))
示例#8
0
 def test_decode_cf_with_multiple_missing_values(self):
     original = Variable(['t'], [0, 1, 2],
                         {'missing_value': np.array([0, 1])})
     expected = Variable(['t'], [np.nan, np.nan, 2], {})
     with warnings.catch_warnings(record=True) as w:
         actual = conventions.decode_cf_variable('t', original)
         assert_identical(expected, actual)
         assert 'has multiple fill' in str(w[0].message)
示例#9
0
 def test_decode_cf_with_multiple_missing_values(self):
     original = Variable(['t'], [0, 1, 2],
                         {'missing_value': np.array([0, 1])})
     expected = Variable(['t'], [np.nan, np.nan, 2], {})
     with warnings.catch_warnings(record=True) as w:
         actual = conventions.decode_cf_variable(original)
         self.assertDatasetIdentical(expected, actual)
         self.assertIn('variable has multiple fill', str(w[0].message))
示例#10
0
def test_encode_decode_roundtrip_cftime(freq):
    initial_time = cftime_range("0001", periods=1)
    times = initial_time.append(
        cftime_range("0001", periods=2, freq=freq) +
        timedelta(days=291000 * 365))
    variable = Variable(["time"], times)
    encoded = conventions.encode_cf_variable(variable)
    decoded = conventions.decode_cf_variable("time", encoded, use_cftime=True)
    assert_equal(variable, decoded)
示例#11
0
def test_encode_decode_roundtrip_datetime64(freq):
    # See GH 4045. Prior to GH 4684 this test would fail for frequencies of
    # "S", "L", "U", and "N".
    initial_time = pd.date_range("1678-01-01", periods=1)
    times = initial_time.append(pd.date_range("1968", periods=2, freq=freq))
    variable = Variable(["time"], times)
    encoded = conventions.encode_cf_variable(variable)
    decoded = conventions.decode_cf_variable("time", encoded)
    assert_equal(variable, decoded)
示例#12
0
def test_CFMaskCoder_encode_missing_fill_values_conflict(data, encoding):
    original = xr.Variable(("x", ), data, encoding=encoding)
    encoded = encode_cf_variable(original)

    assert encoded.dtype == encoded.attrs["missing_value"].dtype
    assert encoded.dtype == encoded.attrs["_FillValue"].dtype

    with pytest.warns(variables.SerializationWarning):
        roundtripped = decode_cf_variable("foo", encoded)
        assert_identical(roundtripped, original)
示例#13
0
    def test_decode_cf_with_conflicting_fill_missing_value(self):
        var = Variable(['t'], np.arange(10),
                       {'units': 'foobar',
                        'missing_value': 0,
                        '_FillValue': 1})
        with raises_regex(ValueError, "_FillValue and missing_value"):
            conventions.decode_cf_variable('t', var)

        var = Variable(['t'], np.arange(10),
                       {'units': 'foobar',
                        'missing_value': np.nan,
                        '_FillValue': np.nan})
        var = conventions.decode_cf_variable('t', var)
        self.assertIsNotNone(var)

        var = Variable(['t'], np.arange(10),
                       {'units': 'foobar',
                        'missing_value': np.float32(np.nan),
                        '_FillValue': np.float32(np.nan)})
        var = conventions.decode_cf_variable('t', var)
        self.assertIsNotNone(var)
示例#14
0
def test_decode_encode_roundtrip_with_non_lowercase_letters(calendar):
    # See GH 5093.
    times = [0, 1]
    units = "days since 2000-01-01"
    attrs = {"calendar": calendar, "units": units}
    variable = Variable(["time"], times, attrs)
    decoded = conventions.decode_cf_variable("time", variable)
    encoded = conventions.encode_cf_variable(decoded)

    # Previously this would erroneously be an array of cftime.datetime
    # objects.  We check here that it is decoded properly to np.datetime64.
    assert np.issubdtype(decoded.dtype, np.datetime64)

    # Use assert_identical to ensure that the calendar attribute maintained its
    # original form throughout the roundtripping process, uppercase letters and
    # all.
    assert_identical(variable, encoded)
示例#15
0
def test_decode_cf_variable_timedelta64():
    variable = Variable(["time"], pd.timedelta_range("1D", periods=2))
    decoded = conventions.decode_cf_variable("time", variable)
    assert decoded.encoding == {}
    assert_identical(decoded, variable)
示例#16
0
def test_decode_cf_variable_cftime():
    variable = Variable(["time"], cftime_range("2000", periods=2))
    decoded = conventions.decode_cf_variable("time", variable)
    assert decoded.encoding == {}
    assert_identical(decoded, variable)
示例#17
0
 def test_decode_cf_variable_with_array_units(self) -> None:
     v = Variable(["t"], [1, 2, 3], {"units": np.array(["foobar"], dtype=object)})
     v_decoded = conventions.decode_cf_variable("test2", v)
     assert_identical(v, v_decoded)