Bug fix: some cloning methods to use super/abstract cloning

Author: mattgebert

pyNexafs/nexafs/__init__.py

@@ -4,7 +4,7 @@
 This includes treating the data, such as normalising it, and performing background subtraction.
 """
 
-from pyNexafs.nexafs.scan import scan_base, scan_abstract
+from pyNexafs.nexafs.scan import scan_base, scan_abstract, scan_simple
 from pyNexafs.nexafs.scan_normalised import (
     scan_normalised,
     scan_normalised_edges,

pyNexafs/nexafs/scan.py

@@ -50,6 +50,44 @@ def __init__(self) -> None:
         self._y_units = []  # List[str]
         return
 
+    @abc.abstractmethod
+    def copy(self, *args, **kwargs) -> scan_abstract:
+        """
+        Creates a copy of the scan object.
+        Reloads parser object data, but links to the same parser object as `self`.
+
+        Returns
+        -------
+        scan_abstract
+            A copy of the scan object with unique data.
+        """
+        newobj = type(self)(*args, **kwargs)
+
+        # Copy Data
+        newobj._x = self._x.copy() if self._x is not None else None
+        newobj._y = self._y.copy() if self._y is not None else None
+        newobj._y_errs = self._y_errs.copy() if self._y_errs is not None else None
+        newobj._x_errs = self._x_errs.copy() if self._x_errs is not None else None
+
+        # Copy Labels and Units
+        newobj._x_label = self._x_label
+        newobj._x_unit = self._x_unit
+        if self._y_labels is not None:
+            if isinstance(self._y_labels, list):
+                newobj._y_labels = [label for label in self._y_labels]
+            else:  # string
+                newobj._y_labels = self._y_labels
+        else:
+            newobj._y_labels = None
+        if self._y_units is not None:
+            if isinstance(self._y_units, list):
+                newobj._y_units = [unit for unit in self._y_units]
+            else:  # string
+                newobj._y_units = self._y_units
+        else:
+            newobj._y_units = None
+        return newobj
+
     @property
     def ctime(self) -> datetime.datetime:
         """
@@ -366,44 +404,6 @@ def y_units(self, units: list[str] | None):
             raise ValueError(f"Provided 'units' {units} is not a list of strings.")
         return
 
-    def copy(self, *args, **kwargs) -> Type[Self]:
-        """
-        Creates a copy of the scan object.
-        Does reload parser object data, but does link to the same parser object.
-
-        Returns
-        -------
-        Type[scan_base]
-            A copy of the scan object with unique data.
-        """
-        newobj = type(self)(parser=None, *args, **kwargs)
-        newobj.parser = self.parser
-
-        # Copy Data
-        newobj._x = self._x.copy()
-        newobj._y = self._y.copy()
-        newobj._y_errs = self._y_errs.copy() if self._y_errs is not None else None
-        newobj._x_errs = self._x_errs.copy() if self._x_errs is not None else None
-
-        # Copy Labels and Units
-        newobj._x_label = self._x_label
-        newobj._x_unit = self._x_unit
-        if self._y_labels is not None:
-            if isinstance(self._y_labels, list):
-                newobj._y_labels = [label for label in self._y_labels]
-            else:  # string
-                newobj._y_labels = self._y_labels
-        else:
-            newobj._y_labels = None
-        if self._y_units is not None:
-            if isinstance(self._y_units, list):
-                newobj._y_units = [unit for unit in self._y_units]
-            else:  # string
-                newobj._y_units = self._y_units
-        else:
-            newobj._y_units = None
-        return newobj
-
     def snapshot(self, columns: int = None) -> matplotlib.figure.Figure:
         """
         Generates a grid of plots, showing all scan data.
@@ -438,6 +438,31 @@ def reload_labels_from_parser(self) -> None:
         pass
 
 
+class scan_simple(scan_abstract):
+    """
+    Basic interface class for raw data that is not bundled in a parser object.
+    """
+
+    def __init__(self, x: npt.NDArray, y: npt.NDArray, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._x = x
+        self._y = y
+        return
+
+    def reload_labels_from_parser(self) -> None:
+        return None
+
+    @overrides.overrides
+    def copy(self) -> scan_simple:
+        """
+        Creates a copy of the scan object.
+
+        Data is unique for a `scan_simple` object, so no need to reload parser data unlike scan_abstract.
+        """
+        new_obj = scan_simple(x=self.x.copy(), y=self.y.copy())
+        return new_obj
+
+
 class scan_base(scan_abstract):
     """
     Base class for synchrotron measurements that scans across photon beam energies (eV).
@@ -481,6 +506,13 @@ def __init__(
             self._load_from_parser(load_all_columns=load_all_columns)
             self._all_columns_loaded = load_all_columns
 
+    @overrides.overrides
+    def copy(self) -> type[scan_base]:
+        newobj = super().copy(
+            parser=self.parser, load_all_columns=self._all_columns_loaded
+        )
+        return newobj
+
     @property
     def ctime(self) -> datetime.datetime:
         """

pyNexafs/nexafs/scan_normalised.py

@@ -8,7 +8,7 @@
 from scipy import optimize as sopt
 from enum import Enum
 from types import NoneType
-from typing import Type
+from typing import Type, Self
 from pyNexafs.nexafs.scan import scan_base, scan_abstract
 
 
@@ -22,12 +22,26 @@ class scan_abstract_normalised(scan_abstract, metaclass=abc.ABCMeta):
         A scan object. Could be already normalised scan or a scan_base object.
     """
 
-    def __init__(self, scan: Type[scan_abstract]):
+    def __init__(self, scan: scan_abstract):
         self._origin = scan
         return
 
+    @overrides.overrides
+    @abc.abstractmethod
+    def copy(self) -> scan_abstract_normalised:
+        """
+        Returns a copy of the scan object.
+
+        Returns
+        -------
+        scan_abstract
+            A copy of the scan object.
+        """
+        copy_obj = type(self)(scan=self._origin)
+        return copy_obj
+
     @property
-    def origin(self) -> Type[scan_base]:
+    def origin(self) -> scan_abstract:
         """
         Property for the original scan object.
 
@@ -113,7 +127,7 @@ def x_label(self) -> str:
         return self.origin.x_label
 
     @x_label.setter
-    def x_label(self, label: str) -> None:
+    def x_label(self, label: str | None) -> None:
         """
         Property setter for the x-axis label, to the origin scan.
 
@@ -223,7 +237,7 @@ def y_units(self) -> list[str]:
         return self.origin.y_units
 
     @y_units.setter
-    def y_units(self, units: list[str]) -> None:
+    def y_units(self, units: list[str] | None) -> None:
         """
         Property setter for the y-axis units, to the origin scan.
 
@@ -245,8 +259,12 @@ def __init__(
             raise ValueError("X data for scan and background scan do not match.")
         if scan.y.shape != scan_background.y.shape:
             raise ValueError("Y data for scan and background scan do not match.")
-        self._origin = scan
+
+        super().__init__(scan)
         self._background = scan_background
+
+        # Run the normalisation
+        self.load_and_normalise()
         return
 
     @overrides.overrides
@@ -287,6 +305,10 @@ def _scale_from_normalisation_data(self) -> None:
             )
         return
 
+    @overrides.overrides
+    def copy(self) -> scan_background_subtraction:
+        return scan_background_subtraction(self._origin, self._background)
+
 
 class scan_normalised(scan_abstract_normalised):
     """
@@ -585,6 +607,17 @@ def y_units(self, units: list[str] | None) -> None:
         self._origin.y_units = units
         return
 
+    def copy(self) -> Self:
+        """
+        Returns a copy of the scan object.
+
+        Returns
+        -------
+        scan_abstract
+            A copy of the scan object.
+        """
+        return scan_normalised(self._origin, norm_channel=self._norm_channel)
+
 
 class scan_normalised_background_channel(scan_normalised):
     """
@@ -599,8 +632,8 @@ class scan_normalised_background_channel(scan_normalised):
     @overrides.overrides
     def __init__(
         self,
-        scan: Type[scan_abstract],
-        background_scan: Type[scan_abstract],
+        scan: scan_abstract,
+        background_scan: scan_abstract,
         norm_channel: str,
     ) -> None:
         # Save background scan and channel information
@@ -619,7 +652,8 @@ def __init__(
     @overrides.overrides
     def _load_from_origin(self):
         # Reload background_scan data
-        self._background_scan.load_from_origin()
+        if hasattr(self._background_scan, "_load_from_origin"):
+            self._background_scan.load_from_origin()
         # Reload scan data
         super()._load_from_origin()
 
@@ -746,9 +780,9 @@ class POSTEDGE_NORM_TYPE(Enum):
 
     def __init__(
         self,
-        scan: Type[scan_base],
-        pre_edge_domain=list[int] | tuple[float, float] | None,
-        post_edge_domain=list[int] | tuple[float, float] | None,
+        scan: Type[scan_abstract],
+        pre_edge_domain: list[int] | tuple[float, float] | None,
+        post_edge_domain: list[int] | tuple[float, float] | None,
         pre_edge_normalisation: PREEDGE_NORM_TYPE = PREEDGE_NORM_TYPE.CONSTANT,
         post_edge_normalisation: POSTEDGE_NORM_TYPE = POSTEDGE_NORM_TYPE.CONSTANT,
         pre_edge_level: float | None = None,
@@ -780,6 +814,19 @@ def __init__(
         self.load_and_normalise()
         return
 
+    @overrides.overrides
+    def copy(self) -> scan_normalised_edges:
+        clone = scan_normalised_edges(
+            self._origin,
+            pre_edge_domain=self._pre_edge_domain,
+            post_edge_domain=self._post_edge_domain,
+            pre_edge_normalisation=self.pre_edge_normalisation,
+            post_edge_normalisation=self.post_edge_normalisation,
+            pre_edge_level=self._pre_edge_level,
+            post_edge_level=self._post_edge_level,
+        )
+        return clone
+
     @overrides.overrides
     def _scale_from_normalisation_data(self) -> None:
         """
@@ -811,7 +858,9 @@ def _scale_from_normalisation_data(self) -> None:
                 ).nonzero()
                 # Check indexes of each tuple element
                 if len(pre_inds[0]) == 0:
-                    raise ValueError("Pre-edge domain is empty.")
+                    raise ValueError(
+                        f"Pre-edge domain ({self.pre_edge_domain[0]} to {self.pre_edge_domain[1]}) contains no datapoints."
+                    )
             else:
                 raise AttributeError(
                     "Pre-edge domain is not defined correctly. Should be a list of indexes or the range in a tuple."
@@ -879,15 +928,17 @@ def _scale_from_normalisation_data(self) -> None:
             if isinstance(self.post_edge_domain, list):
                 post_inds = self.post_edge_domain
                 if len(post_inds) == 0:
-                    raise ValueError("Pre-edge index list is empty.")
+                    raise ValueError("Post-edge index list is empty.")
             elif isinstance(self.post_edge_domain, tuple):
                 post_inds = np.where(
                     (self.x >= self.post_edge_domain[0])
                     & (self.x <= self.post_edge_domain[1])
                 )
                 # Check indexes of each tuple element
                 if len(post_inds[0]) == 0:
-                    raise ValueError("Pre-edge domain is empty.")
+                    raise ValueError(
+                        f"Post-edge domain ({self.post_edge_domain[0]} to {self.post_edge_domain[1]}) contains no datapoints."
+                    )
             else:
                 raise AttributeError(
                     "Post-edge domain is not defined correctly. Should be a list of indexes or the range in a tuple."