From 6476dd0625f01cd8f19e94d7e9d9393eb8b31c41 Mon Sep 17 00:00:00 2001 From: lbdreyer Date: Wed, 2 Aug 2017 14:23:25 +0100 Subject: [PATCH 1/2] Remove usages of replace method --- lib/iris/tests/test_analysis.py | 6 +- lib/iris/tests/test_basic_maths.py | 3 +- lib/iris/tests/test_cdm.py | 4 +- lib/iris/tests/test_concatenate.py | 4 +- lib/iris/tests/test_interpolation.py | 2 +- .../regrid/test_RectilinearRegridder.py | 2 +- lib/iris/tests/unit/cube/test_Cube.py | 79 --------- .../unit/data_manager/test_DataManager.py | 152 ------------------ .../unit/fileformats/pp/test_as_pairs.py | 3 +- 9 files changed, 11 insertions(+), 244 deletions(-) diff --git a/lib/iris/tests/test_analysis.py b/lib/iris/tests/test_analysis.py index 0ffd7e18ab..c58731bf62 100644 --- a/lib/iris/tests/test_analysis.py +++ b/lib/iris/tests/test_analysis.py @@ -129,13 +129,13 @@ def test_weighted_mean_little(self): # to catch cases where there is a loss of precision however. if a.dtype > np.float32: cast_data = a.data.astype(np.float32) - a.replace(cast_data, fill_value=a.fill_value) + a.data = cast_data self.assertCMLApproxData(a, ('analysis', 'weighted_mean_lat.cml')) b = cube.collapsed(lon_coord, iris.analysis.MEAN, weights=weights) if b.dtype > np.float32: cast_data = b.data.astype(np.float32) - b.replace(cast_data, fill_value=b.fill_value) + b.data = cast_data b.data = np.asarray(b.data) self.assertCMLApproxData(b, ('analysis', 'weighted_mean_lon.cml')) self.assertEqual(b.coord('dummy').shape, (1, )) @@ -144,7 +144,7 @@ def test_weighted_mean_little(self): c = cube.collapsed([lat_coord[:], lon_coord], iris.analysis.MEAN, weights=weights) if c.dtype > np.float32: cast_data = c.data.astype(np.float32) - c.replace(cast_data, fill_value=c.fill_value) + c.data = cast_data self.assertCMLApproxData(c, ('analysis', 'weighted_mean_latlon.cml')) self.assertEqual(c.coord('dummy').shape, (1, )) diff --git a/lib/iris/tests/test_basic_maths.py b/lib/iris/tests/test_basic_maths.py index 9d9dc195d4..6f626acb5b 100644 --- a/lib/iris/tests/test_basic_maths.py +++ b/lib/iris/tests/test_basic_maths.py @@ -39,8 +39,7 @@ class TestBasicMaths(tests.IrisTest): def setUp(self): self.cube = iris.tests.stock.global_pp() - self.cube.replace(self.cube.data - 260, - fill_value=self.cube.fill_value) + self.cube.data = self.cube.data - 260 def test_abs(self): a = self.cube diff --git a/lib/iris/tests/test_cdm.py b/lib/iris/tests/test_cdm.py index 1e03bdfbf4..1c4a8cefb8 100644 --- a/lib/iris/tests/test_cdm.py +++ b/lib/iris/tests/test_cdm.py @@ -1030,13 +1030,13 @@ def collapse_test_common(self, cube, a_name, b_name, *args, **kwargs): # want to catch cases where there is a loss of precision however. if dual_stage.dtype > cube.dtype: data = dual_stage.data.astype(cube.dtype) - dual_stage.replace(data, fill_value=dual_stage.fill_value) + dual_stage.data = data self.assertCMLApproxData(dual_stage, ('cube_collapsed', '%s_%s_dual_stage.cml' % (a_filename, b_filename)), *args, **kwargs) single_stage = cube.collapsed([a_name, b_name], iris.analysis.MEAN) if single_stage.dtype > cube.dtype: data = single_stage.data.astype(cube.dtype) - single_stage.replace(data, fill_value=single_stage.fill_value) + single_stage.data = data self.assertCMLApproxData(single_stage, ('cube_collapsed', '%s_%s_single_stage.cml' % (a_filename, b_filename)), *args, **kwargs) # Compare the cube bits that should match diff --git a/lib/iris/tests/test_concatenate.py b/lib/iris/tests/test_concatenate.py index ee03370509..03e8f5f72e 100644 --- a/lib/iris/tests/test_concatenate.py +++ b/lib/iris/tests/test_concatenate.py @@ -518,7 +518,7 @@ def test_concat_masked_2y2d_int16_with_concrete_and_lazy(self): cubes.append(cube) mask = [(0, 1), (1, 0)] cube = _make_cube(x, (2, 4), 2, dtype=dtype, mask=mask) - cube.replace(cube.lazy_data(), dtype=dtype, fill_value=fill_value) + cube.data = cube.lazy_data() cubes.append(cube) result = concatenate(cubes) self.assertCML(result, ('concatenate', 'concat_masked_2y2d_int16.cml')) @@ -539,7 +539,7 @@ def test_concat_masked_2y2d_int16_with_lazy_and_concrete(self): fill_value = -37 mask = [(0, 1), (1, 0)] cube = _make_cube(x, (2, 4), 2, dtype=dtype, mask=mask) - cube.replace(cube.lazy_data(), dtype=dtype, fill_value=fill_value) + cube.data = cube.lazy_data() cubes.append(cube) mask = [(0, 1), (0, 1)] cube = _make_cube(x, (0, 2), 1, dtype=dtype, mask=mask, diff --git a/lib/iris/tests/test_interpolation.py b/lib/iris/tests/test_interpolation.py index 9880c6add6..d840d3852e 100644 --- a/lib/iris/tests/test_interpolation.py +++ b/lib/iris/tests/test_interpolation.py @@ -43,7 +43,7 @@ def normalise_order(cube): # * scipy.interpolate.interp1d in 0.11.0 which is used in # `Linear1dExtrapolator`. data = np.ascontiguousarray(cube.data) - cube.replace(data, fill_value=cube.fill_value) + cube.data = data class TestLinearExtrapolator(tests.IrisTest): diff --git a/lib/iris/tests/unit/analysis/regrid/test_RectilinearRegridder.py b/lib/iris/tests/unit/analysis/regrid/test_RectilinearRegridder.py index 9f968a9ed6..7e4a0be9bf 100644 --- a/lib/iris/tests/unit/analysis/regrid/test_RectilinearRegridder.py +++ b/lib/iris/tests/unit/analysis/regrid/test_RectilinearRegridder.py @@ -1263,7 +1263,7 @@ def test_circular_src__masked_missingmask(self): # instead of being an array. src = self.src src.coord('longitude').circular = True - src.replace(ma.MaskedArray(src.data), fill_value=src.fill_value) + src.data = ma.MaskedArray(src.data, fill_value=src.fill_value) self.assertEqual(src.data.mask, False) method_results = self._check_circular_results(src, 'missingmask') for method_result in method_results: diff --git a/lib/iris/tests/unit/cube/test_Cube.py b/lib/iris/tests/unit/cube/test_Cube.py index 14dba07b85..5fec458f50 100644 --- a/lib/iris/tests/unit/cube/test_Cube.py +++ b/lib/iris/tests/unit/cube/test_Cube.py @@ -1259,85 +1259,6 @@ def regridder(self, src, target): self.assertEqual(result, (scheme, cube, mock.sentinel.TARGET, cube)) -class Test_replace(tests.IrisTest): - def test(self): - cube = stock.simple_1d() - data = np.ones(cube.shape) - cube.replace(data) - self.assertIs(cube.core_data(), data) - - def test__lazy(self): - cube = stock.simple_1d() - data = as_lazy_data(cube.data) - cube.replace(data) - self.assertIs(cube.core_data(), data) - self.assertTrue(cube.has_lazy_data()) - - def test__lazy_with_dtype_change(self): - lazy = as_lazy_data(np.array(10.0)) - dtype = np.dtype('int16') - cube = Cube(lazy) - cube.replace(lazy * 10, dtype=dtype) - self.assertEqual(cube.dtype, dtype) - self.assertEqual(cube.core_data().dtype, lazy.dtype) - - def test__lazy_masked_with_dtype_change(self): - real = ma.array(10) - real.mask = True - lazy = as_lazy_data(real) - dtype = np.dtype('int16') - cube = Cube(lazy, dtype=real.dtype) - self.assertEqual(cube.dtype, real.dtype) - self.assertEqual(cube.core_data().dtype, lazy.dtype) - cube.replace(lazy * 10, dtype=dtype) - self.assertEqual(cube.dtype, dtype) - self.assertEqual(cube.core_data().dtype, lazy.dtype) - - def test__dtype_fill_value_clearance(self): - real = np.array(10.0) - lazy = as_lazy_data(real) - dtype = np.dtype('int16') - fill_value = 10 - cube = Cube(lazy, dtype=dtype, fill_value=fill_value) - self.assertEqual(cube.dtype, dtype) - self.assertEqual(cube.fill_value, fill_value) - cube.replace(real) - self.assertEqual(cube.dtype, real.dtype) - self.assertIsNone(cube.fill_value) - self.assertIs(cube.core_data(), real) - - def test__shape_failure(self): - cube = stock.simple_1d() - data = np.array([0]) - emsg = 'Require data with shape \(11,\), got \(1,\).' - with self.assertRaisesRegexp(ValueError, emsg): - cube.replace(data) - - def test__lazy_failure(self): - cube = stock.simple_1d() - data = np.ones(cube.shape) - dtype = np.dtype('int16') - emsg = 'Cannot set realised dtype, no lazy data is available' - with self.assertRaisesRegexp(ValueError, emsg): - cube.replace(data, dtype=dtype) - - def test__dtype_failure(self): - lazy = as_lazy_data(np.array(10.0, dtype=np.dtype('float64'))) - cube = Cube(lazy) - dtype = np.dtype('float32') - emsg = 'Can only cast lazy data to an integer or boolean dtype' - with self.assertRaisesRegexp(ValueError, emsg): - cube.replace(lazy, dtype=dtype) - - def test__promote_shape_with_dtype_failure(self): - data = np.array(666) - cube = Cube(data) - emsg = 'Cannot set realised dtype, no lazy data is available' - with self.assertRaisesRegexp(ValueError, emsg): - cube.replace(data, dtype=np.dtype('float32')) - self.assertArrayEqual(cube.data, data) - - class Test_copy(tests.IrisTest): def _check_copy(self, cube, cube_copy): self.assertIsNot(cube_copy, cube) diff --git a/lib/iris/tests/unit/data_manager/test_DataManager.py b/lib/iris/tests/unit/data_manager/test_DataManager.py index 61eae3b357..cae7324068 100644 --- a/lib/iris/tests/unit/data_manager/test_DataManager.py +++ b/lib/iris/tests/unit/data_manager/test_DataManager.py @@ -1107,157 +1107,5 @@ def test_with_lazy_array(self): self.assertIs(result, dm._lazy_array) -class Test_replace(tests.IrisTest): - def setUp(self): - self.shape = (2, 3, 4) - self.size = np.prod(self.shape) - self.real_array = np.arange(self.size).reshape(self.shape) - - def test_real_with_real(self): - dm = DataManager(self.real_array * 10) - self.assertFalse(dm.has_lazy_data()) - dm.replace(self.real_array) - self.assertFalse(dm.has_lazy_data()) - self.assertIs(dm._real_array, self.real_array) - self.assertIs(dm.data, self.real_array) - - def test_real_with_lazy(self): - lazy_array = as_lazy_data(self.real_array) - dm = DataManager(self.real_array) - self.assertFalse(dm.has_lazy_data()) - dm.replace(lazy_array) - self.assertTrue(dm.has_lazy_data()) - self.assertIs(dm._lazy_array, lazy_array) - self.assertArrayEqual(dm.data, self.real_array) - - def test_lazy_with_real(self): - lazy_array = as_lazy_data(self.real_array) - dm = DataManager(lazy_array * 10) - self.assertTrue(dm.has_lazy_data()) - dm.replace(self.real_array) - self.assertFalse(dm.has_lazy_data()) - self.assertIs(dm._real_array, self.real_array) - self.assertIs(dm.data, self.real_array) - - def test_lazy_with_lazy(self): - lazy_array = as_lazy_data(self.real_array) - dm = DataManager(lazy_array * 10) - self.assertTrue(dm.has_lazy_data()) - dm.replace(lazy_array) - self.assertTrue(dm.has_lazy_data()) - self.assertIs(dm._lazy_array, lazy_array) - self.assertArrayEqual(dm.data, self.real_array) - - def test_lazy_with_real__realised_dtype_none(self): - mask_array = ma.arange(self.size).reshape(self.shape) - dtype = mask_array.dtype - lazy_array = as_lazy_data(mask_array) - dm = DataManager(lazy_array, realised_dtype=dtype) - self.assertTrue(dm.has_lazy_data()) - self.assertIsNone(dm._realised_dtype, dtype) - self.assertEqual(dm.dtype, dtype) - dm.replace(mask_array) - self.assertFalse(dm.has_lazy_data()) - self.assertIsNone(dm._realised_dtype) - self.assertEqual(dm.dtype, dtype) - self.assertIs(dm._real_array, mask_array) - self.assertIs(dm.data, mask_array) - - def test_lazy_with_real__realised_dtype_clearance(self): - mask_array = ma.arange(self.size).reshape(self.shape) - mask_array[0, 0, 0] = ma.masked - dtype = mask_array.dtype - lazy_array = as_lazy_data(mask_array) - dm = DataManager(lazy_array, realised_dtype=dtype) - self.assertTrue(dm.has_lazy_data()) - self.assertEqual(dm._realised_dtype, dtype) - self.assertEqual(dm.dtype, dtype) - dm.replace(mask_array) - self.assertFalse(dm.has_lazy_data()) - self.assertIsNone(dm._realised_dtype) - self.assertEqual(dm.dtype, dtype) - self.assertIs(dm._real_array, mask_array) - self.assertIs(dm.data, mask_array) - - def test_real_with_lazy__realised_dtype_setter_none(self): - mask_array = ma.masked_array(self.real_array) * 10 - dtype = mask_array.dtype - lazy_array = as_lazy_data(mask_array) - dm = DataManager(self.real_array) - self.assertFalse(dm.has_lazy_data()) - self.assertIsNone(dm._realised_dtype) - self.assertEqual(dm.dtype, dtype) - dm.replace(lazy_array, realised_dtype=dtype) - self.assertTrue(dm.has_lazy_data()) - self.assertIsNone(dm._realised_dtype) - self.assertEqual(dm.dtype, dtype) - self.assertIs(dm._lazy_array, lazy_array) - self.assertArrayEqual(dm.data, mask_array) - - def test_real_with_lazy__realised_dtype_setter(self): - mask_array = ma.masked_array(self.real_array) * 10 - mask_array[0, 0, 0] = ma.masked - dtype = mask_array.dtype - lazy_array = as_lazy_data(mask_array) - lazy_dtype = np.dtype('int16') - dm = DataManager(self.real_array) - self.assertFalse(dm.has_lazy_data()) - self.assertIsNone(dm._realised_dtype) - self.assertEqual(dm.dtype, dtype) - dm.replace(lazy_array, realised_dtype=lazy_dtype) - self.assertTrue(dm.has_lazy_data()) - self.assertEqual(dm._realised_dtype, lazy_dtype) - self.assertEqual(dm.dtype, lazy_dtype) - self.assertIs(dm._lazy_array, lazy_array) - self.assertArrayEqual(dm.data, mask_array) - - def test_real_with_real__realised_dtype_failure(self): - dm = DataManager(self.real_array) - emsg = 'Cannot set realised dtype, no lazy data is available.' - with self.assertRaisesRegexp(ValueError, emsg): - dm.replace(self.real_array * 10, - realised_dtype=np.dtype('int16')) - self.assertIs(dm._real_array, self.real_array) - self.assertArrayEqual(dm.data, self.real_array) - - def test_real_with_real__promote_shape_with_dtype_failure(self): - data = np.array(666) - dm = DataManager(data) - emsg = 'Cannot set realised dtype, no lazy data is available' - with self.assertRaisesRegexp(ValueError, emsg): - dm.replace(np.array([999]), - realised_dtype=np.dtype('float32')) - self.assertArrayEqual(dm.data, data) - - def test__clear_fill_value(self): - fill_value = 1234 - dm = DataManager(np.array(0), fill_value=fill_value) - self.assertEqual(dm.fill_value, fill_value) - dm.replace(np.array(1)) - self.assertIsNone(dm.fill_value) - - def test__clear_fill_value_masked(self): - fill_value = 1234 - dm = DataManager(np.array(0), fill_value=fill_value) - self.assertEqual(dm.fill_value, fill_value) - data = ma.masked_array(1, fill_value=4321) - dm.replace(data) - self.assertIsNone(dm.fill_value) - - def test__set_fill_value(self): - fill_value = 1234 - dm = DataManager(np.array(0)) - self.assertIsNone(dm.fill_value) - dm.replace(np.array(0), fill_value=fill_value) - self.assertEqual(dm.fill_value, fill_value) - - def test__set_fill_value_failure(self): - dm = DataManager(np.array(0)) - self.assertIsNone(dm.fill_value) - emsg = 'Fill value of .* invalid for dtype' - with self.assertRaisesRegexp(ValueError, emsg): - dm.replace(np.array(1), fill_value=1e+20) - - if __name__ == '__main__': tests.main() diff --git a/lib/iris/tests/unit/fileformats/pp/test_as_pairs.py b/lib/iris/tests/unit/fileformats/pp/test_as_pairs.py index 7ba752d90f..7f726613a5 100644 --- a/lib/iris/tests/unit/fileformats/pp/test_as_pairs.py +++ b/lib/iris/tests/unit/fileformats/pp/test_as_pairs.py @@ -51,8 +51,7 @@ def test_field_coords(self): def test_lazy_data(self): cube = self.cube.copy() # "Rebase" the cube onto a lazy version of its data. - cube.replace(cube.lazy_data(), dtype=cube.dtype, - fill_value=cube.fill_value) + cube.data = cube.lazy_data() # Check that lazy data is preserved in save-pairs generation. slices_and_fields = pp.as_pairs(cube) for aslice, _ in slices_and_fields: From 160ca439888eeb652e3d98d649b2aebfd47319ff Mon Sep 17 00:00:00 2001 From: lbdreyer Date: Thu, 3 Aug 2017 10:14:40 +0100 Subject: [PATCH 2/2] Remove fill_value setting from test --- .../tests/unit/analysis/regrid/test_RectilinearRegridder.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/iris/tests/unit/analysis/regrid/test_RectilinearRegridder.py b/lib/iris/tests/unit/analysis/regrid/test_RectilinearRegridder.py index 7e4a0be9bf..ca86e5cdd7 100644 --- a/lib/iris/tests/unit/analysis/regrid/test_RectilinearRegridder.py +++ b/lib/iris/tests/unit/analysis/regrid/test_RectilinearRegridder.py @@ -1263,7 +1263,7 @@ def test_circular_src__masked_missingmask(self): # instead of being an array. src = self.src src.coord('longitude').circular = True - src.data = ma.MaskedArray(src.data, fill_value=src.fill_value) + src.data = ma.MaskedArray(src.data) self.assertEqual(src.data.mask, False) method_results = self._check_circular_results(src, 'missingmask') for method_result in method_results: