reflectorch 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

reflectorch/inference/preprocess_exp/__init__.py

@@ -1,7 +1,7 @@
-from reflectorch.inference.preprocess_exp.preprocess import (
-    standard_preprocessing,
-    StandardPreprocessing,
-)
-from reflectorch.inference.preprocess_exp.interpolation import interp_reflectivity
-from reflectorch.inference.preprocess_exp.attenuation import apply_attenuation_correction
+from reflectorch.inference.preprocess_exp.preprocess import (
+    standard_preprocessing,
+    StandardPreprocessing,
+)
+from reflectorch.inference.preprocess_exp.interpolation import interp_reflectivity
+from reflectorch.inference.preprocess_exp.attenuation import apply_attenuation_correction
 from reflectorch.inference.preprocess_exp.footprint import apply_footprint_correction

reflectorch/inference/preprocess_exp/attenuation.py

@@ -1,36 +1,36 @@
-import numpy as np
-
-
-def apply_attenuation_correction(
-        intensity: np.ndarray,
-        attenuation: np.ndarray,
-        scattering_angle: np.ndarray = None,
-        correct_discontinuities: bool = True
-) -> np.ndarray:
-    """Applies attenuation correction to experimental reflectivity curves
-
-    Args:
-        intensity (np.ndarray): intensities of an experimental reflectivity curve
-        attenuation (np.ndarray): attenuation factors for each measured point
-        scattering_angle (np.ndarray, optional): scattering angles of the measured points. Defaults to None.
-        correct_discontinuities (bool, optional): whether to correct discontinuities in the measured curves. Defaults to True.
-
-    Returns:
-        np.ndarray: the corrected reflectivity curve
-    """
-    intensity = intensity / attenuation
-    if correct_discontinuities:
-        if scattering_angle is None:
-            raise ValueError("correct_discontinuities options requires scattering_angle, but scattering_angle is None.")
-        intensity = apply_discontinuities_correction(intensity, scattering_angle)
-    return intensity
-
-
-def apply_discontinuities_correction(intensity: np.ndarray, scattering_angle: np.ndarray) -> np.ndarray:
-    intensity = intensity.copy()
-    diff_angle = np.diff(scattering_angle)
-    for i in range(len(diff_angle)):
-        if diff_angle[i] == 0:
-            factor = intensity[i] / intensity[i + 1]
-            intensity[(i + 1):] *= factor
-    return intensity
+import numpy as np
+
+
+def apply_attenuation_correction(
+        intensity: np.ndarray,
+        attenuation: np.ndarray,
+        scattering_angle: np.ndarray = None,
+        correct_discontinuities: bool = True
+) -> np.ndarray:
+    """Applies attenuation correction to experimental reflectivity curves
+
+    Args:
+        intensity (np.ndarray): intensities of an experimental reflectivity curve
+        attenuation (np.ndarray): attenuation factors for each measured point
+        scattering_angle (np.ndarray, optional): scattering angles of the measured points. Defaults to None.
+        correct_discontinuities (bool, optional): whether to correct discontinuities in the measured curves. Defaults to True.
+
+    Returns:
+        np.ndarray: the corrected reflectivity curve
+    """
+    intensity = intensity / attenuation
+    if correct_discontinuities:
+        if scattering_angle is None:
+            raise ValueError("correct_discontinuities options requires scattering_angle, but scattering_angle is None.")
+        intensity = apply_discontinuities_correction(intensity, scattering_angle)
+    return intensity
+
+
+def apply_discontinuities_correction(intensity: np.ndarray, scattering_angle: np.ndarray) -> np.ndarray:
+    intensity = intensity.copy()
+    diff_angle = np.diff(scattering_angle)
+    for i in range(len(diff_angle)):
+        if diff_angle[i] == 0:
+            factor = intensity[i] / intensity[i + 1]
+            intensity[(i + 1):] *= factor
+    return intensity

reflectorch/inference/preprocess_exp/cut_with_q_ratio.py

@@ -1,31 +1,31 @@
-import numpy as np
-
-from reflectorch.utils import angle_to_q
-
-
-def cut_curve(q: np.ndarray, curve: np.ndarray, max_q: float, max_angle: float, wavelength: float):
-    """Cuts an experimental reflectivity curve at a maximum q position
-
-    Args:
-        q (np.ndarray): the array of q points
-        curve (np.ndarray): the experimental reflectivity curve
-        max_q (float): the maximum q value at which the curve is cut
-        max_angle (float): the maximum scattering angle at which the curve is cut; only used if max_q is not provided
-        wavelength (float): the wavelength of the beam
-
-    Returns:
-        tuple: the q array after cutting, the reflectivity curve after cutting, and the ratio between the maximum q after cutting and before cutting
-    """
-    if max_angle is None and max_q is None:
-        q_ratio = 1.
-    else:
-        if max_q is None:
-            max_q = angle_to_q(max_angle, wavelength)
-
-        q_ratio = max_q / q.max()
-
-        if q_ratio < 1.:
-            idx = np.argmax(q > max_q)
-            q = q[:idx] / q_ratio
-            curve = curve[:idx]
-    return q, curve, q_ratio
+import numpy as np
+
+from reflectorch.utils import angle_to_q
+
+
+def cut_curve(q: np.ndarray, curve: np.ndarray, max_q: float, max_angle: float, wavelength: float):
+    """Cuts an experimental reflectivity curve at a maximum q position
+
+    Args:
+        q (np.ndarray): the array of q points
+        curve (np.ndarray): the experimental reflectivity curve
+        max_q (float): the maximum q value at which the curve is cut
+        max_angle (float): the maximum scattering angle at which the curve is cut; only used if max_q is not provided
+        wavelength (float): the wavelength of the beam
+
+    Returns:
+        tuple: the q array after cutting, the reflectivity curve after cutting, and the ratio between the maximum q after cutting and before cutting
+    """
+    if max_angle is None and max_q is None:
+        q_ratio = 1.
+    else:
+        if max_q is None:
+            max_q = angle_to_q(max_angle, wavelength)
+
+        q_ratio = max_q / q.max()
+
+        if q_ratio < 1.:
+            idx = np.argmax(q > max_q)
+            q = q[:idx] / q_ratio
+            curve = curve[:idx]
+    return q, curve, q_ratio

reflectorch/inference/preprocess_exp/footprint.py

@@ -1,81 +1,81 @@
-try:
-    from typing import Literal
-except ImportError:
-    from typing_extensions import Literal
-
-import numpy as np
-from scipy.special import erf
-
-__all__ = [
-    "apply_footprint_correction",
-    "remove_footprint_correction",
-    "BEAM_SHAPE",
-]
-
-
-BEAM_SHAPE = Literal["gauss", "box"]
-
-
-def apply_footprint_correction(
-    intensity: np.ndarray,
-    scattering_angle: np.ndarray,
-    beam_width: float,
-    sample_length: float,
-    beam_shape: BEAM_SHAPE = "gauss",
-) -> np.ndarray:
-    """Applies footprint correction to an experimental reflectivity curve
-
-    Args:
-        intensity (np.ndarray): reflectivity curve
-        scattering_angle (np.ndarray): array of scattering angles
-        beam_width (float): the beam width
-        sample_length (float): the sample length
-        beam_shape (BEAM_SHAPE, optional): the shape of the beam, either "gauss" or "box". Defaults to "gauss".
-
-    Returns:
-        np.ndarray: the footprint corrected reflectivity curve
-    """
-    factors = _get_factors_by_beam_shape(
-        scattering_angle, beam_width, sample_length, beam_shape
-    )
-    return intensity.copy() * factors
-
-
-def remove_footprint_correction(
-    intensity: np.ndarray,
-    scattering_angle: np.ndarray,
-    beam_width: float,
-    sample_length: float,
-    beam_shape: BEAM_SHAPE = "gauss",
-):
-    factors = _get_factors_by_beam_shape(
-        scattering_angle, beam_width, sample_length, beam_shape
-    )
-    return intensity.copy() / factors
-
-
-def _get_factors_by_beam_shape(
-    scattering_angle: np.ndarray, beam_width: float, sample_length: float, beam_shape: BEAM_SHAPE
-):
-    if beam_shape == "gauss":
-        return gaussian_factors(scattering_angle, beam_width, sample_length)
-    elif beam_shape == "box":
-        return box_factors(scattering_angle, beam_width, sample_length)
-    else:
-        raise ValueError("invalid beam shape")
-
-
-def box_factors(scattering_angle, beam_width, sample_length):
-    max_angle = 2 * np.arcsin(beam_width / sample_length) / np.pi * 180
-    ratios = beam_footprint_ratio(scattering_angle, beam_width, sample_length)
-    ones = np.ones_like(scattering_angle)
-    return np.where(scattering_angle < max_angle, ones * ratios, ones)
-
-
-def gaussian_factors(scattering_angle, beam_width, sample_length):
-    ratio = beam_footprint_ratio(scattering_angle, beam_width, sample_length)
-    return 1 / erf(np.sqrt(np.log(2)) / ratio)
-
-
-def beam_footprint_ratio(scattering_angle, beam_width, sample_length):
-    return beam_width / sample_length / np.sin(scattering_angle / 2 * np.pi / 180)
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal
+
+import numpy as np
+from scipy.special import erf
+
+__all__ = [
+    "apply_footprint_correction",
+    "remove_footprint_correction",
+    "BEAM_SHAPE",
+]
+
+
+BEAM_SHAPE = Literal["gauss", "box"]
+
+
+def apply_footprint_correction(
+    intensity: np.ndarray,
+    scattering_angle: np.ndarray,
+    beam_width: float,
+    sample_length: float,
+    beam_shape: BEAM_SHAPE = "gauss",
+) -> np.ndarray:
+    """Applies footprint correction to an experimental reflectivity curve
+
+    Args:
+        intensity (np.ndarray): reflectivity curve
+        scattering_angle (np.ndarray): array of scattering angles
+        beam_width (float): the beam width
+        sample_length (float): the sample length
+        beam_shape (BEAM_SHAPE, optional): the shape of the beam, either "gauss" or "box". Defaults to "gauss".
+
+    Returns:
+        np.ndarray: the footprint corrected reflectivity curve
+    """
+    factors = _get_factors_by_beam_shape(
+        scattering_angle, beam_width, sample_length, beam_shape
+    )
+    return intensity.copy() * factors
+
+
+def remove_footprint_correction(
+    intensity: np.ndarray,
+    scattering_angle: np.ndarray,
+    beam_width: float,
+    sample_length: float,
+    beam_shape: BEAM_SHAPE = "gauss",
+):
+    factors = _get_factors_by_beam_shape(
+        scattering_angle, beam_width, sample_length, beam_shape
+    )
+    return intensity.copy() / factors
+
+
+def _get_factors_by_beam_shape(
+    scattering_angle: np.ndarray, beam_width: float, sample_length: float, beam_shape: BEAM_SHAPE
+):
+    if beam_shape == "gauss":
+        return gaussian_factors(scattering_angle, beam_width, sample_length)
+    elif beam_shape == "box":
+        return box_factors(scattering_angle, beam_width, sample_length)
+    else:
+        raise ValueError("invalid beam shape")
+
+
+def box_factors(scattering_angle, beam_width, sample_length):
+    max_angle = 2 * np.arcsin(beam_width / sample_length) / np.pi * 180
+    ratios = beam_footprint_ratio(scattering_angle, beam_width, sample_length)
+    ones = np.ones_like(scattering_angle)
+    return np.where(scattering_angle < max_angle, ones * ratios, ones)
+
+
+def gaussian_factors(scattering_angle, beam_width, sample_length):
+    ratio = beam_footprint_ratio(scattering_angle, beam_width, sample_length)
+    return 1 / erf(np.sqrt(np.log(2)) / ratio)
+
+
+def beam_footprint_ratio(scattering_angle, beam_width, sample_length):
+    return beam_width / sample_length / np.sin(scattering_angle / 2 * np.pi / 180)

reflectorch/inference/preprocess_exp/interpolation.py

@@ -1,19 +1,19 @@
-import numpy as np
-
-
-def interp_reflectivity(q_interp, q, reflectivity, min_value: float = 1e-10, logspace = False):
-    """Interpolate data on a base 10 logarithmic scale
-
-    Args:
-        q_interp (array-like): reciprocal space points used for the interpolation
-        q (array-like): reciprocal space points of the measured reflectivity curve
-        reflectivity (array-like): reflectivity curve measured at the points ``q``
-        min_value (float, optional): minimum intensity of the reflectivity curve. Defaults to 1e-10.
-
-    Returns:
-        array-like: interpolated reflectivity curve
-    """
-    if not(logspace):
-        return 10 ** np.interp(q_interp, q, np.log10(np.clip(reflectivity, min_value, None)))
-    else:
-        return 10 ** np.interp(np.log10(q_interp), np.log10(q), np.log10(np.clip(reflectivity, min_value, None)))
+import numpy as np
+
+
+def interp_reflectivity(q_interp, q, reflectivity, min_value: float = 1e-10, logspace = False):
+    """Interpolate data on a base 10 logarithmic scale
+
+    Args:
+        q_interp (array-like): reciprocal space points used for the interpolation
+        q (array-like): reciprocal space points of the measured reflectivity curve
+        reflectivity (array-like): reflectivity curve measured at the points ``q``
+        min_value (float, optional): minimum intensity of the reflectivity curve. Defaults to 1e-10.
+
+    Returns:
+        array-like: interpolated reflectivity curve
+    """
+    if not(logspace):
+        return 10 ** np.interp(q_interp, q, np.log10(np.clip(reflectivity, min_value, None)))
+    else:
+        return 10 ** np.interp(np.log10(q_interp), np.log10(q), np.log10(np.clip(reflectivity, min_value, None)))

reflectorch/inference/preprocess_exp/normalize.py

@@ -1,21 +1,21 @@
-try:
-    from typing import Literal
-except ImportError:
-    from typing_extensions import Literal
-
-import numpy as np
-from numpy import ndarray
-
-NORMALIZE_MODE = Literal["first", "max", "incoming_intensity"]
-
-
-def intensity2reflectivity(intensity: ndarray, mode: NORMALIZE_MODE, incoming_intensity=None) -> np.ndarray:
-    if mode == "first":
-        return intensity / intensity[0]
-    if mode == "max":
-        return intensity / intensity.max()
-    if mode == "incoming_intensity":
-        if incoming_intensity is None:
-            raise ValueError("incoming_intensity is None")
-        return intensity / incoming_intensity
-    raise ValueError(f"Unknown mode {mode}")
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal
+
+import numpy as np
+from numpy import ndarray
+
+NORMALIZE_MODE = Literal["first", "max", "incoming_intensity"]
+
+
+def intensity2reflectivity(intensity: ndarray, mode: NORMALIZE_MODE, incoming_intensity=None) -> np.ndarray:
+    if mode == "first":
+        return intensity / intensity[0]
+    if mode == "max":
+        return intensity / intensity.max()
+    if mode == "incoming_intensity":
+        if incoming_intensity is None:
+            raise ValueError("incoming_intensity is None")
+        return intensity / incoming_intensity
+    raise ValueError(f"Unknown mode {mode}")

reflectorch/inference/preprocess_exp/preprocess.py

@@ -1,121 +1,121 @@
-from dataclasses import dataclass
-
-import numpy as np
-
-from reflectorch.inference.preprocess_exp.interpolation import interp_reflectivity
-from reflectorch.inference.preprocess_exp.footprint import apply_footprint_correction, BEAM_SHAPE
-from reflectorch.inference.preprocess_exp.normalize import intensity2reflectivity, NORMALIZE_MODE
-from reflectorch.inference.preprocess_exp.attenuation import apply_attenuation_correction
-from reflectorch.inference.preprocess_exp.cut_with_q_ratio import cut_curve
-from reflectorch.utils import angle_to_q
-
-
-def standard_preprocessing(
-        intensity: np.ndarray,
-        scattering_angle: np.ndarray,
-        attenuation: np.ndarray,
-        q_interp: np.ndarray,
-        wavelength: float,
-        beam_width: float,
-        sample_length: float,
-        min_intensity: float = 1e-10,
-        beam_shape: BEAM_SHAPE = "gauss",
-        normalize_mode: NORMALIZE_MODE = "max",
-        incoming_intensity: float = None,
-        max_q: float = None,  # if provided, max_angle is ignored
-        max_angle: float = None,
-) -> dict:
-    """Preprocesses a raw experimental reflectivity curve by applying attenuation correction, footprint correction, cutting at a maximum q value and interpolation
-
-    Args:
-        intensity (np.ndarray): array of intensities of the reflectivity curve
-        scattering_angle (np.ndarray): array of scattering angles
-        attenuation (np.ndarray): attenuation factors for each measured point
-        q_interp (np.ndarray): reciprocal space points used for the interpolation
-        wavelength (float): the wavelength of the beam
-        beam_width (float): the beam width
-        sample_length (float): the sample length
-        min_intensity (float, optional): intensities lower than this value are removed. Defaults to 1e-10.
-        beam_shape (BEAM_SHAPE, optional): the shape of the beam, either "gauss" or "box". Defaults to "gauss".
-        normalize_mode (NORMALIZE_MODE, optional): normalization mode, either "first", "max" or "incoming_intensity". Defaults to "max".
-        incoming_intensity (float, optional): array of intensities for the "incoming_intensity" normalization. Defaults to None.
-        max_q (float, optional): the maximum q value at which the curve is cut. Defaults to None.
-        max_angle (float, optional): the maximum scattering angle at which the curve is cut; only used if max_q is not provided. Defaults to None.
-
-    Returns:
-        dict: dictionary containing the interpolated reflectivity curve, the curve before interpolation, the q values before interpolation, the q values after interpolation and the q ratio of the cutting
-    """
-    intensity = apply_attenuation_correction(
-        intensity,
-        attenuation,
-        scattering_angle,
-    )
-
-    intensity = apply_footprint_correction(
-        intensity, scattering_angle, beam_width=beam_width, sample_length=sample_length, beam_shape=beam_shape
-    )
-
-    curve = intensity2reflectivity(intensity, normalize_mode, incoming_intensity)
-
-    curve, scattering_angle = remove_low_statistics(curve, scattering_angle, thresh=min_intensity)
-
-    q = angle_to_q(scattering_angle, wavelength)
-
-    q, curve, q_ratio = cut_curve(q, curve, max_q, max_angle, wavelength)
-
-    curve_interp = interp_reflectivity(q_interp, q, curve)
-
-    assert np.all(np.isfinite(curve_interp))
-    assert np.all(np.isfinite(curve))
-    assert np.all(np.isfinite(q))
-    assert np.all(np.isfinite(q_interp))
-    assert np.all(curve > 0.)
-    assert np.all(curve_interp > 0.)
-
-    return {
-        "curve_interp": curve_interp, "curve": curve, "q_values": q, "q_interp": q_interp, "q_ratio": q_ratio,
-    }
-
-
-def remove_low_statistics(curve, scattering_angle, thresh: float = 1e-7):
-    indices = (curve > thresh) & np.isfinite(curve)
-    return curve[indices], scattering_angle[indices]
-
-
-@dataclass
-class StandardPreprocessing:
-    q_interp: np.ndarray = None
-    wavelength: float = 1.
-    beam_width: float = None
-    sample_length: float = None
-    beam_shape: BEAM_SHAPE = "gauss"
-    normalize_mode: NORMALIZE_MODE = "max"
-    incoming_intensity: float = None
-
-    def preprocess(self,
-                   intensity: np.ndarray,
-                   scattering_angle: np.ndarray,
-                   attenuation: np.ndarray,
-                   **kwargs
-                   ) -> dict:
-        attrs = self._get_updated_attrs(**kwargs)
-        return standard_preprocessing(
-            intensity,
-            scattering_angle,
-            attenuation,
-            **attrs
-        )
-
-    __call__ = preprocess
-
-    def set_parameters(self, **kwargs) -> None:
-        for k, v in kwargs.items():
-            if k in self.__annotations__:
-                setattr(self, k, v)
-            else:
-                raise KeyError(f'Unknown parameter {k}.')
-
-    def _get_updated_attrs(self, **kwargs):
-        current_attrs = {k: getattr(self, k) for k in self.__annotations__.keys()}
-        current_attrs.update(kwargs)
-        return current_attrs
+from dataclasses import dataclass
+
+import numpy as np
+
+from reflectorch.inference.preprocess_exp.interpolation import interp_reflectivity
+from reflectorch.inference.preprocess_exp.footprint import apply_footprint_correction, BEAM_SHAPE
+from reflectorch.inference.preprocess_exp.normalize import intensity2reflectivity, NORMALIZE_MODE
+from reflectorch.inference.preprocess_exp.attenuation import apply_attenuation_correction
+from reflectorch.inference.preprocess_exp.cut_with_q_ratio import cut_curve
+from reflectorch.utils import angle_to_q
+
+
+def standard_preprocessing(
+        intensity: np.ndarray,
+        scattering_angle: np.ndarray,
+        attenuation: np.ndarray,
+        q_interp: np.ndarray,
+        wavelength: float,
+        beam_width: float,
+        sample_length: float,
+        min_intensity: float = 1e-10,
+        beam_shape: BEAM_SHAPE = "gauss",
+        normalize_mode: NORMALIZE_MODE = "max",
+        incoming_intensity: float = None,
+        max_q: float = None,  # if provided, max_angle is ignored
+        max_angle: float = None,
+) -> dict:
+    """Preprocesses a raw experimental reflectivity curve by applying attenuation correction, footprint correction, cutting at a maximum q value and interpolation
+
+    Args:
+        intensity (np.ndarray): array of intensities of the reflectivity curve
+        scattering_angle (np.ndarray): array of scattering angles
+        attenuation (np.ndarray): attenuation factors for each measured point
+        q_interp (np.ndarray): reciprocal space points used for the interpolation
+        wavelength (float): the wavelength of the beam
+        beam_width (float): the beam width
+        sample_length (float): the sample length
+        min_intensity (float, optional): intensities lower than this value are removed. Defaults to 1e-10.
+        beam_shape (BEAM_SHAPE, optional): the shape of the beam, either "gauss" or "box". Defaults to "gauss".
+        normalize_mode (NORMALIZE_MODE, optional): normalization mode, either "first", "max" or "incoming_intensity". Defaults to "max".
+        incoming_intensity (float, optional): array of intensities for the "incoming_intensity" normalization. Defaults to None.
+        max_q (float, optional): the maximum q value at which the curve is cut. Defaults to None.
+        max_angle (float, optional): the maximum scattering angle at which the curve is cut; only used if max_q is not provided. Defaults to None.
+
+    Returns:
+        dict: dictionary containing the interpolated reflectivity curve, the curve before interpolation, the q values before interpolation, the q values after interpolation and the q ratio of the cutting
+    """
+    intensity = apply_attenuation_correction(
+        intensity,
+        attenuation,
+        scattering_angle,
+    )
+
+    intensity = apply_footprint_correction(
+        intensity, scattering_angle, beam_width=beam_width, sample_length=sample_length, beam_shape=beam_shape
+    )
+
+    curve = intensity2reflectivity(intensity, normalize_mode, incoming_intensity)
+
+    curve, scattering_angle = remove_low_statistics(curve, scattering_angle, thresh=min_intensity)
+
+    q = angle_to_q(scattering_angle, wavelength)
+
+    q, curve, q_ratio = cut_curve(q, curve, max_q, max_angle, wavelength)
+
+    curve_interp = interp_reflectivity(q_interp, q, curve)
+
+    assert np.all(np.isfinite(curve_interp))
+    assert np.all(np.isfinite(curve))
+    assert np.all(np.isfinite(q))
+    assert np.all(np.isfinite(q_interp))
+    assert np.all(curve > 0.)
+    assert np.all(curve_interp > 0.)
+
+    return {
+        "curve_interp": curve_interp, "curve": curve, "q_values": q, "q_interp": q_interp, "q_ratio": q_ratio,
+    }
+
+
+def remove_low_statistics(curve, scattering_angle, thresh: float = 1e-7):
+    indices = (curve > thresh) & np.isfinite(curve)
+    return curve[indices], scattering_angle[indices]
+
+
+@dataclass
+class StandardPreprocessing:
+    q_interp: np.ndarray = None
+    wavelength: float = 1.
+    beam_width: float = None
+    sample_length: float = None
+    beam_shape: BEAM_SHAPE = "gauss"
+    normalize_mode: NORMALIZE_MODE = "max"
+    incoming_intensity: float = None
+
+    def preprocess(self,
+                   intensity: np.ndarray,
+                   scattering_angle: np.ndarray,
+                   attenuation: np.ndarray,
+                   **kwargs
+                   ) -> dict:
+        attrs = self._get_updated_attrs(**kwargs)
+        return standard_preprocessing(
+            intensity,
+            scattering_angle,
+            attenuation,
+            **attrs
+        )
+
+    __call__ = preprocess
+
+    def set_parameters(self, **kwargs) -> None:
+        for k, v in kwargs.items():
+            if k in self.__annotations__:
+                setattr(self, k, v)
+            else:
+                raise KeyError(f'Unknown parameter {k}.')
+
+    def _get_updated_attrs(self, **kwargs):
+        current_attrs = {k: getattr(self, k) for k in self.__annotations__.keys()}
+        current_attrs.update(kwargs)
+        return current_attrs