Remove usages of replace() method

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, ))
 

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

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

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,

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):

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)
         self.assertEqual(src.data.mask, False)
         method_results = self._check_circular_results(src, 'missingmask')
         for method_result in method_results:

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)

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()

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: