Merge pull request #2526 from kif/2525_copy_result

Ensure all results containers are `copy`able and `deepcopy` able

Author: kif

src/pyFAI/containers.py

@@ -30,10 +30,11 @@
 __contact__ = "valentin.valls@esrf.eu"
 __license__ = "MIT"
 __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
-__date__ = "04/04/2025"
+__date__ = "16/05/2025"
 __status__ = "development"
 
 import sys
+import copy
 from dataclasses import fields, asdict, dataclass as _dataclass
 from collections import namedtuple
 from enum import IntEnum
@@ -55,7 +56,6 @@
     dataclass = _dataclass
 
 
-
 class ErrorModel(IntEnum):
     NO = 0
     VARIANCE = 1
@@ -91,10 +91,45 @@ def as_str(self):
         return self.name.lower()
 
 
-class IntegrateResult(tuple):
+class _CopyableTuple(tuple):
+    "Abstract class that can be copied using the copy module"
+    COPYABLE_ATTR = tuple()  # list of copyable attributes
+
+    def __copy__(self):
+        "Helper function for copy.copy()"
+        other = self.__class__(*self)
+        for attr in self.COPYABLE_ATTR:
+            setattr(other, attr, getattr(self, attr))
+        return other
+
+    def __deepcopy__(self, memo=None):
+        "Helper function for copy.deepcopy()"
+        if memo is None:
+            memo = {}
+        args = []
+        for i in self:
+            cpy = copy.deepcopy(i, memo)
+            memo[id(i)] = cpy
+            args.append(cpy)
+        other = self.__class__(*args)
+        for attr in self.COPYABLE_ATTR:
+            org = getattr(self, attr)
+            cpy = copy.deepcopy(org, memo)
+            memo[id(org)] = cpy
+            setattr(other, attr, cpy)
+        return other
+
+
+class IntegrateResult(_CopyableTuple):
     """
     Class defining shared information between Integrate1dResult and Integrate2dResult.
     """
+    COPYABLE_ATTR = {"_sum_signal", "_sum_variance", "_sum_normalization", "_sum_normalization2",
+                     "_count", "_unit", "_has_mask_applied", "_has_dark_correction",
+                     "_has_flat_correction", "_has_solidangle_correction", "_normalization_factor",
+                     "_polarization_factor", "_metadata", "_npt_azim", "_percentile", "_method",
+                     "_method_called", "_compute_engine", "_error_model", "_std", "_sem",
+                     "_poni", "_weighted_average"}
 
     def __init__(self):
         self._sum_signal = None  # sum of signal
@@ -396,8 +431,7 @@ def _set_error_model(self, value):
 
     @property
     def poni(self):
-        """content of the PONI-file
-        """
+        "content of the PONI-file"
         return self._poni
 
     def _set_poni(self, value):
@@ -594,14 +628,20 @@ def _set_azimuthal_unit(self, unit):
         self._azimuthal_unit = unit
 
 
-class SeparateResult(tuple):
+class SeparateResult(_CopyableTuple):
     """
     Class containing the result of AzimuthalIntegrator.separte which separates the
 
     * Amorphous isotropic signal (from a median filter or a sigma-clip)
     * Bragg peaks (signal > amorphous)
     * Shadow areas (signal < amorphous)
     """
+    COPYABLE_ATTR = {'_radial', '_intensity', '_sigma',
+                    '_sum_signal', '_sum_variance', '_sum_normalization',
+                    '_count', '_unit', '_has_mask_applied', '_has_dark_correction',
+                    '_has_flat_correction', '_normalization_factor', '_polarization_factor',
+                    '_metadata', '_npt_rad', '_npt_azim', '_percentile', '_method',
+                    '_method_called', '_compute_engine', '_shadow'}
 
     def __new__(self, bragg, amorphous):
         return tuple.__new__(SeparateResult, (bragg, amorphous))
@@ -907,8 +947,17 @@ def _set_npt_azim(self, value):
         self._npt_azim = value
 
 
-class SparseFrame(tuple):
+class SparseFrame(_CopyableTuple):
     """Result of the sparsification of a diffraction frame"""
+    COPYABLE_ATTR = {'_shape', '_dtype', '_mask',
+                    '_radius', '_dummy', '_background_avg',
+                    '_background_std', '_unit', '_has_dark_correction',
+                    '_has_flat_correction', '_normalization_factor', '_polarization_factor',
+                    '_metadata', '_percentile', '_method',
+                    '_method_called', '_compute_engine',
+                    '_cutoff_clip', '_cutoff_pick', '_cutoff_peak',
+                    '_background_cycle', '_noise', '_radial_range', '_error_model',
+                    '_peaks', '_peak_patch_size', '_peak_connected'}
 
     def __new__(self, index, intensity):
         return tuple.__new__(SparseFrame, (index, intensity))
@@ -1045,23 +1094,24 @@ def peak_connected(self):
     def unit(self):
         return self._unit
 
+
 def rebin1d(res2d):
     """Function that rebins an Integrate2dResult into a Integrate1dResult
 
     :param res2d: Integrate2dResult instance obtained from ai.integrate2d
     :return: Integrate1dResult
     """
     bins_rad = res2d.radial
-    sum_signal =  res2d.sum_signal.sum(axis=0)
-    sum_normalization =  res2d.sum_normalization.sum(axis=0)
+    sum_signal = res2d.sum_signal.sum(axis=0)
+    sum_normalization = res2d.sum_normalization.sum(axis=0)
     I = sum_signal / sum_normalization
     if res2d.sum_variance is not None:
-        sum_variance =  res2d.sum_variance.sum(axis=0)
+        sum_variance = res2d.sum_variance.sum(axis=0)
         sem = numpy.sqrt(sum_variance) / sum_normalization
         result = Integrate1dResult(bins_rad, I, sem)
         result._set_sum_normalization2(res2d.sum_normalization2.sum(axis=0))
         result._set_sum_variance(sum_variance)
-        result._set_std(numpy.sqrt(sum_variance) / sum_normalization  )
+        result._set_std(numpy.sqrt(sum_variance) / sum_normalization)
         result._set_std(sem)
     else:
         result = Integrate1dResult(bins_rad, I)

src/pyFAI/test/test_bug_regression.py

@@ -36,7 +36,7 @@
 __contact__ = "Jerome.Kieffer@esrf.fr"
 __license__ = "MIT"
 __copyright__ = "2015-2024 European Synchrotron Radiation Facility, Grenoble, France"
-__date__ = "27/09/2024"
+__date__ = "16/05/2025"
 
 import sys
 import os
@@ -599,10 +599,72 @@ def test_bug_2151(self):
         Faulty detectors: S10
         """
         ai = load({"detector": "imxpad_s10"})
-        img=numpy.ones(ai.detector.shape);
+        img = numpy.ones(ai.detector.shape)
         ai.integrate2d(img, 10, method=("full","csc","python"), unit="r_mm")
         #used to raise AssertionError assert self.size == len(indptr) - 1
 
+    def test_bug_2525(self):
+        """
+        res1d_cp = copy.copy(res1d)
+        used to raise TypeError: missing required positional argument
+        """
+        ai = load({"detector": "imxpad_s10"})
+        img = numpy.ones(ai.detector.shape)
+        res1d = ai.integrate1d(img, 10, unit="r_mm")
+
+        res1d_cp = copy.copy(res1d)
+        self.assertTrue(numpy.allclose(res1d.radial, res1d_cp.radial))
+        self.assertTrue(numpy.allclose(res1d.intensity, res1d_cp.intensity))
+        self.assertTrue(numpy.allclose(res1d.sum_signal, res1d_cp._sum_signal))
+        self.assertTrue(numpy.allclose(res1d.sum_normalization, res1d_cp._sum_normalization))
+        res1d_dp = copy.deepcopy(res1d)
+        self.assertTrue(numpy.allclose(res1d.radial, res1d_dp.radial))
+        self.assertTrue(numpy.allclose(res1d.intensity, res1d_dp.intensity))
+        self.assertTrue(numpy.allclose(res1d.sum_signal, res1d_dp.sum_signal))
+        self.assertTrue(numpy.allclose(res1d.sum_normalization, res1d_dp.sum_normalization))
+
+        res2d = ai.integrate2d(img, 10, unit="r_mm")
+        res2d_cp = copy.copy(res2d)
+        self.assertTrue(numpy.allclose(res2d.radial, res2d_cp.radial))
+        self.assertTrue(numpy.allclose(res2d.intensity, res2d_cp.intensity))
+        self.assertTrue(numpy.allclose(res2d.sum_signal, res2d_cp.sum_signal))
+        self.assertTrue(numpy.allclose(res2d.sum_normalization, res2d_cp.sum_normalization))
+        res2d_dp = copy.deepcopy(res2d)
+        self.assertTrue(numpy.allclose(res2d.radial, res2d_dp.radial))
+        self.assertTrue(numpy.allclose(res2d.intensity, res2d_dp.intensity))
+        self.assertTrue(numpy.allclose(res2d.sum_signal, res2d_dp.sum_signal))
+        self.assertTrue(numpy.allclose(res2d.sum_normalization, res2d_dp.sum_normalization))
+
+        ressp = ai.separate(img, 10, unit="r_mm")
+        ressp_cp = copy.copy(ressp)
+        self.assertTrue(numpy.allclose(ressp.bragg, ressp_cp.bragg))
+        self.assertTrue(numpy.allclose(ressp.amorphous, ressp_cp.amorphous))
+        self.assertTrue(numpy.allclose(ressp.sum_signal, ressp_cp.sum_signal))
+        self.assertTrue(numpy.allclose(ressp.sum_normalization, ressp_cp.sum_normalization))
+
+        ressp_dp = copy.deepcopy(ressp)
+        self.assertTrue(numpy.allclose(ressp.bragg, ressp_dp.bragg))
+        self.assertTrue(numpy.allclose(ressp.amorphous, ressp_dp.amorphous))
+        self.assertTrue(numpy.allclose(ressp.sum_signal, ressp_dp.sum_signal))
+        self.assertTrue(numpy.allclose(ressp.sum_normalization, ressp_dp.sum_normalization))
+
+        from pyFAI.containers import SparseFrame
+        sp = SparseFrame(numpy.arange(1,5),numpy.arange(4,9))
+        sp._shape = (23,45)
+        sp_cp = copy.copy(sp)
+        self.assertTrue(numpy.allclose(sp.index, sp_cp.index))
+        self.assertTrue(numpy.allclose(sp.intensity, sp_cp.intensity))
+        self.assertEqual(sp.shape, sp_cp.shape)
+
+        sp_dp = copy.deepcopy(sp)
+        self.assertTrue(numpy.allclose(sp.index, sp_dp.index))
+        self.assertTrue(numpy.allclose(sp.intensity, sp_dp.intensity))
+        self.assertEqual(sp.shape, sp_dp.shape)
+
+
+
+
+
 class TestBug1703(unittest.TestCase):
     """
     Check the normalization affect propely the propagated errors/intensity