Change internal data and mask to private properties

Author: mwcraig

ccdproc/combiner.py

@@ -184,14 +184,14 @@ def __init__(self, ccd_iter, dtype=None, xp=None):
 
         # set up the data array
         # new_shape = (len(ccd_list),) + default_shape
-        self.data_arr = xp.array([ccd.data for ccd in ccd_list], dtype=dtype)
+        self._data_arr = xp.array([ccd.data for ccd in ccd_list], dtype=dtype)
 
         # populate self.data_arr
         mask_list = [
             ccd.mask if ccd.mask is not None else xp.zeros(default_shape)
             for ccd in ccd_list
         ]
-        self.data_arr_mask = xp.array(mask_list, dtype=bool)
+        self._data_arr_mask = xp.array(mask_list, dtype=bool)
 
         # Must be after self.data_arr is defined because it checks the
         # length of the data array.
@@ -222,13 +222,13 @@ def weights(self, value):
             except TypeError as err:
                 raise TypeError("weights must be an array.") from err
 
-            if value.shape != self.data_arr.shape:
+            if value.shape != self._data_arr.shape:
                 if value.ndim != 1:
                     raise ValueError(
                         "1D weights expected when shapes of the "
                         "data and weights differ."
                     )
-                if value.shape[0] != self.data_arr.shape[0]:
+                if value.shape[0] != self._data_arr.shape[0]:
                     raise ValueError(
                         "Length of weights not compatible with specified axis."
                     )
@@ -258,9 +258,9 @@ def scaling(self, value):
         if value is None:
             self._scaling = value
         else:
-            n_images = self.data_arr.shape[0]
+            n_images = self._data_arr.shape[0]
             if callable(value):
-                self._scaling = [value(self.data_arr[i]) for i in range(n_images)]
+                self._scaling = [value(self._data_arr[i]) for i in range(n_images)]
                 self._scaling = xp.array(self._scaling)
             else:
                 try:
@@ -277,7 +277,7 @@ def scaling(self, value):
                     )
                 self._scaling = xp.array(value)
             # reshape so that broadcasting occurs properly
-            for _ in range(len(self.data_arr.shape) - 1):
+            for _ in range(len(self._data_arr.shape) - 1):
                 self._scaling = self.scaling[:, xp.newaxis]
 
     # set up IRAF-like minmax clipping
@@ -329,12 +329,12 @@ def clip_extrema(self, nlow=0, nhigh=0):
         if nhigh is None:
             nhigh = 0
 
-        argsorted = xp.argsort(self.data_arr, axis=0)
+        argsorted = xp.argsort(self._data_arr, axis=0)
         # Not every array package has mgrid, so make it in numpy and convert it to the
         # array package used for the data.
         mg = xp.asarray(
             np_mgrid[
-                [slice(ndim) for i, ndim in enumerate(self.data_arr.shape) if i > 0]
+                [slice(ndim) for i, ndim in enumerate(self._data_arr.shape) if i > 0]
             ]
         )
         for i in range(-1 * nhigh, nlow):
@@ -344,10 +344,10 @@ def clip_extrema(self, nlow=0, nhigh=0):
             # dimensions, so we need to flatten the mask array, set the mask
             # values for a flattened array, and then reshape it back to the
             # original shape.
-            flat_index = np_ravel_multi_index(where, self.data_arr.shape)
-            self.data_arr_mask = xp.reshape(
-                xpx.at(xp.reshape(self.data_arr_mask, (-1,)))[flat_index].set(True),
-                self.data_arr.shape,
+            flat_index = np_ravel_multi_index(where, self._data_arr.shape)
+            self._data_arr_mask = xp.reshape(
+                xpx.at(xp.reshape(self._data_arr_mask, (-1,)))[flat_index].set(True),
+                self._data_arr.shape,
             )
 
     # set up min/max clipping algorithms
@@ -365,13 +365,13 @@ def minmax_clipping(self, min_clip=None, max_clip=None):
             Default is ``None``.
         """
         if min_clip is not None:
-            mask = self.data_arr < min_clip
+            mask = self._data_arr < min_clip
             # Written to avoid in-place modification of array
-            self.data_arr_mask = self.data_arr_mask | mask
+            self._data_arr_mask = self._data_arr_mask | mask
         if max_clip is not None:
-            mask = self.data_arr > max_clip
+            mask = self._data_arr > max_clip
             # Written to avoid in-place modification of array
-            self.data_arr_mask = self.data_arr_mask | mask
+            self._data_arr_mask = self._data_arr_mask | mask
 
     # set up sigma  clipping algorithms
     @deprecated_renamed_argument(
@@ -430,10 +430,10 @@ def sigma_clipping(
         # Remove in 3.0
         _ = kwd.pop("use_astropy", True)
 
-        self.data_arr_mask = (
-            self.data_arr_mask
+        self._data_arr_mask = (
+            self._data_arr_mask
             | sigma_clip(
-                self.data_arr,
+                self._data_arr,
                 sigma_lower=low_thresh,
                 sigma_upper=high_thresh,
                 axis=kwd.get("axis", 0),
@@ -448,18 +448,18 @@ def sigma_clipping(
 
     def _get_scaled_data(self, scale_arg):
         if scale_arg is not None:
-            return self.data_arr * scale_arg
+            return self._data_arr * scale_arg
         if self.scaling is not None:
-            return self.data_arr * self.scaling
-        return self.data_arr
+            return self._data_arr * self.scaling
+        return self._data_arr
 
     def _get_nan_substituted_data(self, data):
         xp = self._xp
 
         # Get the data as an unmasked array with masked values filled as NaN
-        if self.data_arr_mask.any():
+        if self._data_arr_mask.any():
             # Use array_api_extra so that we can use at with all array libraries
-            data = xpx.at(data)[self.data_arr_mask].set(xp.nan)
+            data = xpx.at(data)[self._data_arr_mask].set(xp.nan)
         else:
             data = data
         return data
@@ -478,7 +478,7 @@ def _combination_setup(self, user_func, default_func, scale_to):
             data = self._get_nan_substituted_data(data)
             masked_values = xp.isnan(data).sum(axis=0)
         else:
-            masked_values = self.data_arr_mask.sum(axis=0)
+            masked_values = self._data_arr_mask.sum(axis=0)
             combo_func = user_func
 
         return data, masked_values, combo_func
@@ -532,7 +532,7 @@ def median_combine(
         medianed = median_func(data, axis=0)
 
         # set the mask
-        mask = masked_values == len(self.data_arr)
+        mask = masked_values == len(self._data_arr)
 
         # set the uncertainty
 
@@ -549,7 +549,7 @@ def median_combine(
         # be an array of the same class as the data, so make sure it is
         uncertainty = xp.asarray(uncertainty)
         # Divide uncertainty by the number of pixel (#309)
-        uncertainty /= xp.sqrt(len(self.data_arr) - masked_values)
+        uncertainty /= xp.sqrt(len(self._data_arr) - masked_values)
         # Convert uncertainty to plain numpy array (#351)
         # There is no need to care about potential masks because the
         # uncertainty was calculated based on the data so potential masked
@@ -566,7 +566,7 @@ def median_combine(
         )
 
         # update the meta data
-        combined_image.meta["NCOMBINE"] = len(self.data_arr)
+        combined_image.meta["NCOMBINE"] = len(self._data_arr)
 
         # return the combined image
         return combined_image
@@ -653,7 +653,7 @@ def average_combine(
 
         # calculate the mask
 
-        mask = masked_values == len(self.data_arr)
+        mask = masked_values == len(self._data_arr)
 
         # set up the deviation
         uncertainty = uncertainty_func(data, axis=0)
@@ -729,7 +729,7 @@ def sum_combine(
             summed = sum_func(data, axis=0)
 
         # set up the mask
-        mask = masked_values == len(self.data_arr)
+        mask = masked_values == len(self._data_arr)
 
         # set up the deviation
         uncertainty = uncertainty_func(data, axis=0)
@@ -749,7 +749,7 @@ def sum_combine(
         )
 
         # update the meta data
-        combined_image.meta["NCOMBINE"] = len(self.data_arr)
+        combined_image.meta["NCOMBINE"] = len(self._data_arr)
 
         # return the combined image
         return combined_image

ccdproc/tests/test_combiner.py

@@ -85,16 +85,16 @@ def test_combiner_create():
     ccd_data = ccd_data_func()
     ccd_list = [ccd_data, ccd_data, ccd_data]
     c = Combiner(ccd_list)
-    assert c.data_arr.shape == (3, 100, 100)
-    assert c.data_arr_mask.shape == (3, 100, 100)
+    assert c._data_arr.shape == (3, 100, 100)
+    assert c._data_arr_mask.shape == (3, 100, 100)
 
 
 # test if dtype matches the value that is passed
 def test_combiner_dtype():
     ccd_data = ccd_data_func()
     ccd_list = [ccd_data, ccd_data, ccd_data]
     c = Combiner(ccd_list, dtype=xp.float32)
-    assert c.data_arr.dtype == xp.float32
+    assert c._data_arr.dtype == xp.float32
     avg = c.average_combine()
     # dtype of average should match input dtype
     assert avg.dtype == c.dtype
@@ -114,9 +114,9 @@ def test_combiner_mask():
     ccd = CCDData(data, unit=u.adu, mask=mask)
     ccd_list = [ccd, ccd, ccd]
     c = Combiner(ccd_list)
-    assert c.data_arr.shape == (3, 10, 10)
-    assert c.data_arr_mask.shape == (3, 10, 10)
-    assert not c.data_arr_mask[0, 5, 5]
+    assert c._data_arr.shape == (3, 10, 10)
+    assert c._data_arr_mask.shape == (3, 10, 10)
+    assert not c._data_arr_mask[0, 5, 5]
 
 
 def test_weights():
@@ -158,7 +158,7 @@ def test_pixelwise_weights():
         CCDData(xp.zeros((10, 10)) + 1000, unit=u.adu),
     ]
     combo = Combiner(ccd_list)
-    combo.weights = xp.ones_like(combo.data_arr)
+    combo.weights = xp.ones_like(combo._data_arr)
     combo.weights = xpx.at(combo.weights)[:, 5, 5].set(xp.array([1, 5, 10]))
     ccd = combo.average_combine()
     np_testing.assert_allclose(ccd.data[5, 5], 312.5)
@@ -188,7 +188,7 @@ def test_combiner_minmax_max():
 
     c = Combiner(ccd_list)
     c.minmax_clipping(min_clip=None, max_clip=500)
-    assert c.data_arr_mask[2].all()
+    assert c._data_arr_mask[2].all()
 
 
 def test_combiner_minmax_min():
@@ -200,7 +200,7 @@ def test_combiner_minmax_min():
 
     c = Combiner(ccd_list)
     c.minmax_clipping(min_clip=-500, max_clip=None)
-    assert c.data_arr_mask[1].all()
+    assert c._data_arr_mask[1].all()
 
 
 def test_combiner_sigmaclip_high():
@@ -216,7 +216,7 @@ def test_combiner_sigmaclip_high():
     c = Combiner(ccd_list)
     # using mad for more robust statistics vs. std
     c.sigma_clipping(high_thresh=3, low_thresh=None, func="median", dev_func=mad)
-    assert c.data_arr_mask[5].all()
+    assert c._data_arr_mask[5].all()
 
 
 def test_combiner_sigmaclip_single_pix():
@@ -231,13 +231,13 @@ def test_combiner_sigmaclip_single_pix():
     combo = Combiner(ccd_list)
     # add a single pixel in another array to check that
     # that one gets rejected
-    combo.data_arr = xpx.at(combo.data_arr)[0, 5, 5].set(0)
-    combo.data_arr = xpx.at(combo.data_arr)[1, 5, 5].set(-5)
-    combo.data_arr = xpx.at(combo.data_arr)[2, 5, 5].set(5)
-    combo.data_arr = xpx.at(combo.data_arr)[3, 5, 5].set(-5)
-    combo.data_arr = xpx.at(combo.data_arr)[4, 5, 5].set(25)
+    combo._data_arr = xpx.at(combo._data_arr)[0, 5, 5].set(0)
+    combo._data_arr = xpx.at(combo._data_arr)[1, 5, 5].set(-5)
+    combo._data_arr = xpx.at(combo._data_arr)[2, 5, 5].set(5)
+    combo._data_arr = xpx.at(combo._data_arr)[3, 5, 5].set(-5)
+    combo._data_arr = xpx.at(combo._data_arr)[4, 5, 5].set(25)
     combo.sigma_clipping(high_thresh=3, low_thresh=None, func="median", dev_func=mad)
-    assert combo.data_arr_mask[4, 5, 5]
+    assert combo._data_arr_mask[4, 5, 5]
 
 
 def test_combiner_sigmaclip_low():
@@ -253,7 +253,7 @@ def test_combiner_sigmaclip_low():
     c = Combiner(ccd_list)
     # using mad for more robust statistics vs. std
     c.sigma_clipping(high_thresh=None, low_thresh=3, func="median", dev_func=mad)
-    assert c.data_arr_mask[5].all()
+    assert c._data_arr_mask[5].all()
 
 
 # test that the median combination works and returns a ccddata object
@@ -377,7 +377,7 @@ def test_combiner_with_scaling():
     np_testing.assert_allclose(np_median(med_ccd), np_median(med_inp_data))
 
     # Set the scaling manually...
-    combiner.scaling = [scale_by_mean(combiner.data_arr[i]) for i in range(3)]
+    combiner.scaling = [scale_by_mean(combiner._data_arr[i]) for i in range(3)]
     avg_ccd = combiner.average_combine()
     np_testing.assert_allclose(avg_ccd.data.mean(), ccd_data.data.mean())
     assert avg_ccd.shape == ccd_data.shape
@@ -586,7 +586,7 @@ def test_average_combine_uncertainty():
     ccd_list = [ccd_data, ccd_data, ccd_data]
     c = Combiner(ccd_list)
     ccd = c.average_combine(uncertainty_func=xp.sum)
-    uncert_ref = xp.sum(c.data_arr, 0) / xp.sqrt(3)
+    uncert_ref = xp.sum(c._data_arr, 0) / xp.sqrt(3)
     np_testing.assert_allclose(ccd.uncertainty.array, uncert_ref)
 
     # Compare this also to the "combine" call
@@ -601,7 +601,7 @@ def test_median_combine_uncertainty():
     ccd_list = [ccd_data, ccd_data, ccd_data]
     c = Combiner(ccd_list)
     ccd = c.median_combine(uncertainty_func=xp.sum)
-    uncert_ref = xp.sum(c.data_arr, 0) / xp.sqrt(3)
+    uncert_ref = xp.sum(c._data_arr, 0) / xp.sqrt(3)
     np_testing.assert_allclose(ccd.uncertainty.array, uncert_ref)
 
     # Compare this also to the "combine" call
@@ -616,7 +616,7 @@ def test_sum_combine_uncertainty():
     ccd_list = [ccd_data, ccd_data, ccd_data]
     c = Combiner(ccd_list)
     ccd = c.sum_combine(uncertainty_func=xp.sum)
-    uncert_ref = xp.sum(c.data_arr, 0) * xp.sqrt(3)
+    uncert_ref = xp.sum(c._data_arr, 0) * xp.sqrt(3)
     np_testing.assert_allclose(ccd.uncertainty.array, uncert_ref)
 
     # Compare this also to the "combine" call
@@ -798,8 +798,8 @@ def test_combiner_3d():
     ccd_list = [data1, data2, data3]
 
     c = Combiner(ccd_list)
-    assert c.data_arr.shape == (3, 5, 5, 5)
-    assert c.data_arr_mask.shape == (3, 5, 5, 5)
+    assert c._data_arr.shape == (3, 5, 5, 5)
+    assert c._data_arr_mask.shape == (3, 5, 5, 5)
 
     ccd = c.average_combine()
     assert ccd.shape == (5, 5, 5)
@@ -836,7 +836,7 @@ def test_3d_combiner_with_scaling():
     np_testing.assert_allclose(np_median(med_ccd), np_median(med_inp_data))
 
     # Set the scaling manually...
-    combiner.scaling = [scale_by_mean(combiner.data_arr[i]) for i in range(3)]
+    combiner.scaling = [scale_by_mean(combiner._data_arr[i]) for i in range(3)]
     avg_ccd = combiner.average_combine()
     np_testing.assert_allclose(avg_ccd.data.mean(), ccd_data.data.mean())
     assert avg_ccd.shape == ccd_data.shape
@@ -935,9 +935,9 @@ def test_clip_extrema_with_other_rejection():
     ccdlist[1].data = xpx.at(ccdlist[1].data)[2, 0].set(100.1)
     c = Combiner(ccdlist)
     # Reject ccdlist[1].data[1,2] by other means
-    c.data_arr_mask = xpx.at(c.data_arr_mask)[1, 1, 2].set(True)
+    c._data_arr_mask = xpx.at(c._data_arr_mask)[1, 1, 2].set(True)
     # Reject ccdlist[1].data[1,2] by other means
-    c.data_arr_mask = xpx.at(c.data_arr_mask)[3, 0, 0].set(True)
+    c._data_arr_mask = xpx.at(c._data_arr_mask)[3, 0, 0].set(True)
 
     c.clip_extrema(nlow=1, nhigh=1)
     result = c.average_combine()
@@ -979,8 +979,8 @@ def create_gen():
         yield ccd_data
 
     c = Combiner(create_gen())
-    assert c.data_arr.shape == (3, 100, 100)
-    assert c.data_arr_mask.shape == (3, 100, 100)
+    assert c._data_arr.shape == (3, 100, 100)
+    assert c._data_arr_mask.shape == (3, 100, 100)
 
 
 @pytest.mark.parametrize(
@@ -1057,7 +1057,7 @@ def sum_func(_, axis=axis):
                 return xp.sum(new_data, axis=axis)
 
         expected_result = 3 * data
-        actual_result = c.sum_combine(sum_func=my_summer(c.data_arr, c.data_arr_mask))
+        actual_result = c.sum_combine(sum_func=my_summer(c._data_arr, c._data_arr_mask))
     elif comb_func == "average_combine":
         expected_result = data
         actual_result = c.average_combine(scale_func=xp.mean)