def test_combine_dicts_different(test_mda):
"""Test combination of dictionaries differing in various ways."""
from satpy.dataset.metadata import combine_metadata
mda = {'a': {'b': np.array([1, 2, 3]), 'c': 1.0}, 'd': 'foo'}
test_metadata = [{'raw_metadata': mda}, {'raw_metadata': test_mda}]
result = combine_metadata(*test_metadata)
assert not result
def test_combine_one_metadata_object(self):
"""Test combining one metadata object."""
mda_objects = ({'_FillValue': np.nan,
'valid_range': np.array([0., 0.00032], dtype=np.float32),
'ancillary_variables': ['cpp_status_flag',
'cpp_conditions',
'cpp_quality',
'cpp_reff_pal',
'-'],
'platform_name': 'NOAA-20',
'sensor': {'viirs'}},)
expected = {'_FillValue': np.nan,
'valid_range': np.array([0., 0.00032], dtype=np.float32),
'ancillary_variables': ['cpp_status_flag',
'cpp_conditions',
'cpp_quality',
'cpp_reff_pal',
'-'],
'platform_name': 'NOAA-20',
'sensor': {'viirs'}}
from satpy.dataset.metadata import combine_metadata
result = combine_metadata(*mda_objects)
assert np.allclose(result.pop('_FillValue'), expected.pop('_FillValue'), equal_nan=True)
assert np.allclose(result.pop('valid_range'), expected.pop('valid_range'))
assert result == expected
def test_combine_dicts_close():
"""Test combination of dictionaries whose values are close."""
from satpy.dataset.metadata import combine_metadata
attrs = {
'raw_metadata': {
'a': 1,
'b': 'foo',
'c': [1, 2, 3],
'd': {
'e': np.str('bar'),
'f': datetime(2020, 1, 1, 12, 15, 30),
'g': np.array([1, 2, 3]),
},
'h': np.array([datetime(2020, 1, 1), datetime(2020, 1, 1)])
}
}
attrs_close = {
'raw_metadata': {
'a': 1 + 1E-12,
'b': 'foo',
'c': np.array([1, 2, 3]) + 1E-12,
'd': {
'e': np.str('bar'),
'f': datetime(2020, 1, 1, 12, 15, 30),
'g': np.array([1, 2, 3]) + 1E-12
},
'h': np.array([datetime(2020, 1, 1), datetime(2020, 1, 1)])
}
}
test_metadata = [attrs, attrs_close]
result = combine_metadata(*test_metadata)
assert result == attrs
def test_combine_lists_different_size(self):
"""Test combine metadata with different size lists."""
from satpy.dataset.metadata import combine_metadata
metadatas = [
{'prerequisites': [1, 2, 3, 4]},
{'prerequisites': []},
]
res = combine_metadata(*metadatas)
assert 'prerequisites' not in res
metadatas = [
{'prerequisites': [1, 2, 3, 4]},
{'prerequisites': [1, 2, 3]},
]
res = combine_metadata(*metadatas)
assert 'prerequisites' not in res
def test_combine_numpy_arrays(self):
"""Test combining values that are numpy arrays."""
from satpy.dataset.metadata import combine_metadata
test_metadata = [{'valid_range': np.array([0., 0.00032], dtype=np.float32)},
{'valid_range': np.array([0., 0.00032], dtype=np.float32)},
{'valid_range': np.array([0., 0.00032], dtype=np.float32)}]
result = combine_metadata(*test_metadata)
assert np.allclose(result['valid_range'], np.array([0., 0.00032], dtype=np.float32))
def test_combine_dask_arrays(self):
"""Test combining values that are dask arrays."""
from satpy.dataset.metadata import combine_metadata
import dask.array as da
test_metadata = [{'valid_range': da.from_array(np.array([0., 0.00032], dtype=np.float32))},
{'valid_range': da.from_array(np.array([0., 0.00032], dtype=np.float32))}]
result = combine_metadata(*test_metadata)
assert 'valid_range' not in result
def test_combine_identical_numpy_scalars(self):
"""Test combining idendical fill values."""
from satpy.dataset.metadata import combine_metadata
test_metadata = [{
'_FillValue': np.uint16(42)
}, {
'_FillValue': np.uint16(42)
}]
assert combine_metadata(*test_metadata) == {'_FillValue': 42}
def test_combine_lists_same_size_diff_values(self):
"""Test combine metadata with lists with different values."""
from satpy.dataset.metadata import combine_metadata
metadatas = [
{'prerequisites': [1, 2, 3, 4]},
{'prerequisites': [1, 2, 3, 5]},
]
res = combine_metadata(*metadatas)
assert 'prerequisites' not in res
def test_combine_lists_identical(self):
"""Test combine metadata with identical lists."""
from satpy.dataset.metadata import combine_metadata
metadatas = [
{'prerequisites': [1, 2, 3, 4]},
{'prerequisites': [1, 2, 3, 4]},
]
res = combine_metadata(*metadatas)
assert res['prerequisites'] == [1, 2, 3, 4]
def test_combine_arrays(self):
"""Test the combine_metadata with arrays."""
from satpy.dataset.metadata import combine_metadata
from numpy import arange, ones
from xarray import DataArray
dts = [
{"quality": (arange(25) % 2).reshape(5, 5).astype("?")},
{"quality": (arange(1, 26) % 3).reshape(5, 5).astype("?")},
{"quality": ones((5, 5,), "?")},
]
assert "quality" not in combine_metadata(*dts)
dts2 = [{"quality": DataArray(d["quality"])} for d in dts]
assert "quality" not in combine_metadata(*dts2)
# the ancillary_variables attribute is actually a list of data arrays
dts3 = [{"quality": [d["quality"]]} for d in dts]
assert "quality" not in combine_metadata(*dts3)
# check cases with repeated arrays
dts4 = [
{"quality": dts[0]["quality"]},
{"quality": dts[0]["quality"]},
]
assert "quality" in combine_metadata(*dts4)
dts5 = [
{"quality": dts3[0]["quality"]},
{"quality": dts3[0]["quality"]},
]
assert "quality" in combine_metadata(*dts5)
# check with other types
dts6 = [
DataArray(arange(5), attrs=dts[0]),
DataArray(arange(5), attrs=dts[0]),
DataArray(arange(5), attrs=dts[1]),
object()
]
assert "quality" not in combine_metadata(*dts6)
def test_combine_real_world_mda(self):
"""Test with real data."""
mda_objects = ({'_FillValue': np.nan,
'valid_range': np.array([0., 0.00032], dtype=np.float32),
'ancillary_variables': ['cpp_status_flag',
'cpp_conditions',
'cpp_quality',
'cpp_reff_pal',
'-'],
'platform_name': 'NOAA-20',
'sensor': {'viirs'},
'raw_metadata': {'foo': {'bar': np.array([1, 2, 3])}}},
{'_FillValue': np.nan,
'valid_range': np.array([0., 0.00032], dtype=np.float32),
'ancillary_variables': ['cpp_status_flag',
'cpp_conditions',
'cpp_quality',
'cpp_reff_pal',
'-'],
'platform_name': 'NOAA-20',
'sensor': {'viirs'},
'raw_metadata': {'foo': {'bar': np.array([1, 2, 3])}}})
expected = {'_FillValue': np.nan,
'valid_range': np.array([0., 0.00032], dtype=np.float32),
'ancillary_variables': ['cpp_status_flag',
'cpp_conditions',
'cpp_quality',
'cpp_reff_pal',
'-'],
'platform_name': 'NOAA-20',
'sensor': {'viirs'},
'raw_metadata': {'foo': {'bar': np.array([1, 2, 3])}}}
from satpy.dataset.metadata import combine_metadata
result = combine_metadata(*mda_objects)
assert np.allclose(result.pop('_FillValue'), expected.pop('_FillValue'), equal_nan=True)
assert np.allclose(result.pop('valid_range'), expected.pop('valid_range'))
np.testing.assert_equal(result.pop('raw_metadata'),
expected.pop('raw_metadata'))
assert result == expected
def test_combine_nans(self):
"""Test combining nan fill values."""
from satpy.dataset.metadata import combine_metadata
test_metadata = [{'_FillValue': np.nan}, {'_FillValue': np.nan}]
assert combine_metadata(*test_metadata) == {'_FillValue': np.nan}
def test_combine_empty_metadata(self):
"""Test combining empty metadata."""
from satpy.dataset.metadata import combine_metadata
test_metadata = [{}, {}]
assert combine_metadata(*test_metadata) == {}
def test_combine_times_without_averaging(self):
"""Test the combine_metadata with times without averaging."""
from satpy.dataset.metadata import combine_metadata
ret = combine_metadata(*self.datetime_dts, average_times=False)
# times are not equal so don't include it in the final result
self.assertNotIn('start_time', ret)
def test_combine_times_with_averaging(self):
"""Test the combine_metadata with times with averaging."""
from satpy.dataset.metadata import combine_metadata
ret = combine_metadata(*self.datetime_dts)
self.assertEqual(self.datetime_dts[2]['start_time'], ret['start_time'])
