dkist-processing-common 14.3.6__tar.gz → 14.4.0__tar.gz

{dkist_processing_common-14.3.6 → dkist_processing_common-14.4.0}/CHANGELOG.rst

@@ -1,3 +1,12 @@
+v14.4.0 (2026-08-25)
+====================
+
+Misc
+----
+
+- Convert wavelength calibration quality metric generation to the new storage-based framework. (`#344 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/344>`__)
+
+
 v14.3.6 (2026-08-14)
 ====================
 

{dkist_processing_common-14.3.6 → dkist_processing_common-14.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-common
-Version: 14.3.6
+Version: 14.4.0
 Summary: Common task classes used by the DKIST science data processing pipelines
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause

{dkist_processing_common-14.3.6 → dkist_processing_common-14.4.0}/dkist_processing_common/models/quality.py

@@ -1,6 +1,7 @@
 """Support classes used to create a quality report."""
 
 from datetime import datetime
+from numbers import Real
 from typing import Annotated
 from typing import Any
 
@@ -181,20 +182,50 @@ DatetimeIsoDict = Annotated[
 ]
 
 
-class TimeSeriesData(QualityModel):
+def as_xy_dict(input_value: Any) -> dict[str, Any]:
     """
-    Time Series Data.
+    If required, transform json input from list[list[Any]] to dict[Any, Any].
 
-    The context, e.g. task_type or modstate, is maintained outside of this structure.
+    The nominal input dict is dict[str, tuple[Any, ...]].
+    If already a dict, pass back the dict as is.
+    If a list or tuple, attempt to extract x_values and y_values.
+    """
+    # it's already a dict, no translation
+    if isinstance(input_value, dict):
+        return input_value
+
+    # translate to a dict when appropriate
+    if (
+        isinstance(input_value, (list, tuple))
+        and len(input_value) == 2
+        and isinstance(input_value[0], (list, tuple))
+        and isinstance(input_value[1], (list, tuple))
+    ):
+        return {
+            "x_values": input_value[0],
+            "y_values": input_value[1],
+        }
+
+    # not a dict and not recognized as something that could be a dict
+    # pass back the input value for probable pydantic framework failure
+    return input_value
+
+
+class SeriesData(QualityModel):
+    """
+    Series Data where the data type of the x-axis unspecified.
+
+    This class is intended to be used as a base class.
+    It is not intended for direct implementation primarily because the data type of the x-axis is unspecified.
     """
 
     # by default, a tuple accepts a list as input
     # the use of tuples is intentional because list mutations do not trigger validation
-    # the impact is that TimeSeriesData should not be instantiated until
+    # the impact is that SeriesData should not be instantiated until
     # after the tuple input has been fully accumulated
     # when `mode="json"`, the output of a tuple results in a list
     # when `mode="python"`, the output of a tuple results in a tuple
-    x_values: tuple[DatetimeIsoDict, ...]
+    x_values: tuple[Any, ...]
     # NOTE:  FiniteFloat will fail fast for `nan` and `inf`
     y_values: tuple[FiniteFloat, ...]
 
@@ -204,14 +235,14 @@ class TimeSeriesData(QualityModel):
         axes_are_different_lengths = len(self.x_values) != len(self.y_values)
         if axes_are_different_lengths:
             raise ValueError(
-                f"Cannot store TimeSeriesData with different length axes. "
+                f"Cannot store {self.__class__.__name__} with different length axes. "
                 f"{len(self.x_values)=}, {len(self.y_values)=}"
             )
         # Can't have this AND default to empty tuple
         axes_are_zero_length = not self.x_values or not self.y_values
         if axes_are_zero_length:
             raise ValueError(
-                f"Cannot store TimeSeriesData with 0 length axes. "
+                f"Cannot store {self.__class__.__name__} with 0 length axes. "
                 f"{len(self.x_values)=}, {len(self.y_values)=}"
             )
         return self
@@ -222,30 +253,80 @@ class TimeSeriesData(QualityModel):
         data = handler(self)
         # change structure if mode="json" for QRM compatibility
         if info.mode == "json":
-            # dump as list[list[Any]] with DatetimeIsoDict format for x_values
+            # dump as list[list[Any]] with the specified format for x_values
             return [list(data["x_values"]), list(data["y_values"])]
         return data
 
     @model_validator(mode="before")
     @classmethod
     def handle_json(cls, input_value: Any):
-        """
-        Transform json input from list[list[Any]] to dict[Any, Any].
+        """Transform json input from list[list[Any]] to dict[Any, Any]."""
+        return as_xy_dict(input_value)
 
-        the dict is expected to be dict[str, tuple[Any, ...]], which gets validated by normal BaseModel configurations.
-        """
-        if isinstance(input_value, dict):
-            return input_value
 
-        if (
-            isinstance(input_value, (list, tuple))
-            and len(input_value) == 2
-            and isinstance(input_value[0], (list, tuple))
-            and isinstance(input_value[1], (list, tuple))
-        ):
-            return {"x_values": input_value[0], "y_values": input_value[1]}
+class TimeSeriesData(SeriesData):
+    """
+    Time Series Data.
 
-        return input_value
+    The context, e.g. task_type or modstate, is maintained outside of this structure.
+    """
+
+    # by default, a tuple accepts a list as input
+    # the use of tuples is intentional because list mutations do not trigger validation
+    # the impact is that TimeSeriesData should not be instantiated until
+    # after the tuple input has been fully accumulated
+    # when `mode="json"`, the output of a tuple results in a list
+    # when `mode="python"`, the output of a tuple results in a tuple
+    x_values: tuple[DatetimeIsoDict, ...]
+
+
+class FloatSeriesData(SeriesData):
+    """
+    Float Series Data.
+
+    The context, e.g. task_type or modstate, is maintained outside of this structure.
+    """
+
+    # by default, a tuple accepts a list as input
+    # the use of tuples is intentional because list mutations do not trigger validation
+    # the impact is that FloatSeriesData should not be instantiated until
+    # after the tuple input has been fully accumulated
+    # when `mode="json"`, the output of a tuple results in a list
+    # when `mode="python"`, the output of a tuple results in a tuple
+    # NOTE:  FiniteFloat will fail fast for `nan` and `inf`
+    x_values: tuple[FiniteFloat, ...]
+
+
+def float_or_time_series_data(input_value: Any) -> Any:
+    """
+    Identify the input value as FloatSeriesData or TimeSeriesData.
+
+    This supports reading data from a json encoded file.
+    A float is valid for datetime input, which would lead to non-deterministic behavior.
+    If the x_values appear to be float values, then return a FloatSeriesData instance.
+    Otherwise, return a TimeSeriesData instance.
+    """
+    xy_dict = as_xy_dict(input_value)
+    if not isinstance(xy_dict, dict):
+        # pass back the input value for probable pydantic framework failure
+        return xy_dict
+
+    x_values = xy_dict.get("x_values", ())
+
+    first_x = next((x for x in x_values if x is not None), None)
+
+    if isinstance(first_x, Real):
+        # the decision was made based on the first x value
+        # now validate the data types of all x_values and y_values
+        return FloatSeriesData.model_validate(xy_dict)
+
+    return TimeSeriesData.model_validate(xy_dict)
+
+
+FloatOrTimeSeriesData = Annotated[
+    FloatSeriesData | TimeSeriesData,
+    BeforeValidator(float_or_time_series_data),
+]
 
 
 class XYData(QualityModel):
@@ -255,7 +336,7 @@ class XYData(QualityModel):
     ylabel: str
     # the key is the name assigned to the series, e.g. within the legend
     # the key cannot be None, because `null` is not a valid json key
-    series_data: dict[str, TimeSeriesData] = Field(default_factory=dict)
+    series_data: dict[str, FloatOrTimeSeriesData] = Field(default_factory=dict)
     # TODO FUTURE - convert `series_name` to `legend_title` to better align with matplotlib terminology
     series_name: str | None = None
     ylabel_horizontal: bool | None = None
@@ -299,10 +380,45 @@ class TableData(QualityModel):
 
 
 class MultiPlotData(QualityModel):
-    """Multiple Plot Data."""
+    """
+    Support class to hold a multi-pane plot with plots stacked vertically.
 
-    # TBD
-    pass
+    This type of metric is really geared towards plots that share an X axis and have no gap between them. If you just
+    want two separate plots it's probably better to use a list of `XYData` objects.
+    """
+
+    top_to_bottom_plot_list: list[XYData]
+    match_x_axes: bool = True
+    no_gap: bool = True
+    top_to_bottom_height_ratios: list[float] | None = None
+
+    @field_validator("top_to_bottom_height_ratios")
+    @classmethod
+    def ensure_same_number_of_height_ratios_and_plots(
+        cls, height_ratios: list[float] | None, info: ValidationInfo
+    ) -> list[float]:
+        """
+        Make sure that the number of height ratios is the same as the number of plots.
+
+        Also populates default, same-size ratios if no ratios were given.
+        """
+        try:
+            plot_list = info.data["top_to_bottom_plot_list"]
+        except KeyError:
+            # The plot list didn't validate for some reason. We're about to error anyway.
+            return [1.0]
+
+        num_plots = len(plot_list)
+        if height_ratios is None:
+            return [1.0] * num_plots
+
+        if len(height_ratios) != num_plots:
+            raise ValueError(
+                f"The number of items in `top_to_bottom_height_ratios` list ({len(height_ratios)}) is not "
+                f"the same as the number of plots ({num_plots})"
+            )
+
+        return height_ratios
 
 
 class HistogramData(QualityModel):
@@ -357,10 +473,11 @@ class QualityMetric(QualityModel):
     facet: QualityFacet = None
     statement: list[str] | None = None
     plot_data: list[XYData] | None = None
-    multi_plot_data: list[MultiPlotData] | None = None
+    # NOTE:  specifically NOT a list
+    multi_plot_data: MultiPlotData | None = None
     histogram_data: list[HistogramData] | None = None
     table_data: list[TableData] | None = None
-    modmad_data: list[ModMatData] | None = None
+    modmat_data: list[ModMatData] | None = None
     raincloud_data: list[RaincloudData] | None = None
     efficiency_data: list[EfficiencyData] | None = None
     warnings: list[str] | None = None

dkist_processing_common-14.4.0/dkist_processing_common/tasks/mixin/quality/_base.py

@@ -0,0 +1,218 @@
+"""Base QualityMixin class that contains machinery common to all metric types."""
+
+from typing import Iterable
+
+import astropy.units as u
+import numpy as np
+from solar_wavelength_calibration.fitter.wavelength_fitter import FitResult
+
+from dkist_processing_common.codecs.basemodel import basemodel_encoder
+from dkist_processing_common.codecs.json import json_encoder
+from dkist_processing_common.codecs.quality import QualityValueEncoder
+from dkist_processing_common.models.metric_code import MetricCode
+from dkist_processing_common.models.quality import FloatSeriesData
+from dkist_processing_common.models.quality import MultiPlotData
+from dkist_processing_common.models.quality import QualityMetric
+from dkist_processing_common.models.quality import XYData
+from dkist_processing_common.models.tags import Tag
+from dkist_processing_common.tasks.mixin.quality._metrics import _PolcalQualityMixin
+
+
+class QualityMixin(
+    _PolcalQualityMixin,
+):
+    """Mixin class supporting the generation of the quality reports."""
+
+    def quality_assemble_data(self, polcal_label_list: list[str] | None = None) -> list[dict]:
+        """Assemble the quality data by checking for the existence of each metric."""
+        report = []
+
+        polcal_labels = polcal_label_list or []
+        report += self.quality_polcal_metrics(polcal_labels)
+
+        return report
+
+    def quality_polcal_metrics(self, label_list: list) -> list[dict]:
+        """Encapsulate polcal metric parsing."""
+        result = []
+        for metric_name, metric_func in self.quality_metrics_polcal.items():
+            for label in label_list:
+                if self._quality_metric_exists(metric_name=metric_name, task_type=label):
+                    result.append(metric_func(label=label))
+
+        return result
+
+    @property
+    def quality_metrics_polcal(self) -> dict:
+        """Return a dict of polcal quality metrics."""
+        return {
+            "POLCAL_CONSTANT_PAR_VALS": self.quality_build_polcal_constant_parameter_values,
+            "POLCAL_GLOBAL_PAR_VALS": self.quality_build_polcal_global_parameter_values,
+            "POLCAL_LOCAL_PAR_VALS": self.quality_build_polcal_local_parameter_values,
+            "POLCAL_FIT_RESIDUALS": self.quality_build_polcal_fit_residuals,
+            "POLCAL_EFFICIENCY": self.quality_build_polcal_efficiency,
+        }
+
+    def _quality_metric_exists(self, metric_name: str, task_type: str = None) -> bool:
+        """Look for the existence of data on disk for a quality metric."""
+        tags = [Tag.quality(quality_metric=metric_name)]
+        if task_type:
+            tags.append(Tag.quality_task(quality_task_type=task_type))
+        try:
+            next(self.read(tags=tags))
+            return True
+        except StopIteration:
+            return False
+
+    @staticmethod
+    def _format_warnings(warnings: list[str] | None) -> list[str] | None:
+        """If warnings is an empty list, change its value to None."""
+        return warnings or None
+
+    def _record_values(self, values, tags: Iterable[str] | str):
+        """Serialize and store distributed quality report values for."""
+        self.write(
+            data=values, tags=tags, encoder=json_encoder, allow_nan=False, cls=QualityValueEncoder
+        )
+
+    def quality_metrics_wavecal(
+        self,
+        *,
+        input_wavelength: u.Quantity,
+        input_spectrum: np.ndarray,
+        fit_result: FitResult,
+        weights: None | np.ndarray = None,
+    ):
+        """
+        Store the results of a wavelength solution fit.
+
+        Namely, save the:
+
+        * Input spectrum and wavelength
+        * Best-fit combined atlas spectrum
+        * Best-fit wavelength vector
+        * Fit residuals
+
+        Note that the residuals are the *unweighed* residuals.
+        """
+        weight_data = np.ones(input_wavelength.size) if weights is None else weights
+        prepared_weights = fit_result.prepared_weights
+        residuals = fit_result.minimizer_result.residual / prepared_weights
+        residuals[~np.isfinite(residuals)] = 0.0
+        normalized_residuals = residuals / input_spectrum
+
+        best_fit_atlas = fit_result.best_fit_atlas
+        best_fit_wavelength = fit_result.best_fit_wavelength_vector
+
+        finite_idx = (
+            np.isfinite(input_wavelength)
+            * np.isfinite(input_spectrum)
+            * np.isfinite(best_fit_wavelength)
+            * np.isfinite(best_fit_atlas)
+            * np.isfinite(normalized_residuals)
+            * np.isfinite(weight_data)
+        )
+
+        input_wave_list = input_wavelength.to_value(u.nm)[finite_idx].tolist()
+        input_spectrum_list = input_spectrum[finite_idx].tolist()
+        best_fit_wave_list = best_fit_wavelength[finite_idx].tolist()
+        best_fit_atlas_list = best_fit_atlas[finite_idx].tolist()
+        residuals_list = normalized_residuals[finite_idx].tolist()
+        weights = None if weights is None else weight_data[finite_idx].tolist()
+
+        fit_series = {
+            "Best Fit Observations": FloatSeriesData(
+                x_values=tuple(best_fit_wave_list),
+                y_values=tuple(input_spectrum_list),
+            ),
+            "Input Spectrum": FloatSeriesData(
+                x_values=tuple(input_wave_list),
+                y_values=tuple(input_spectrum_list),
+            ),
+            "Best Fit Atlas": FloatSeriesData(
+                x_values=tuple(best_fit_wave_list),
+                y_values=tuple(best_fit_atlas_list),
+            ),
+        }
+
+        # Set the colors and zorder here manually because the JSON-ization of the quality data means we can't be sure of
+        # the order these will be plotted in and thus can't rely on the default color-cycler in `dkist-quality`.
+        fit_plot_kwargs = {
+            "Best Fit Observations": {
+                "ls": "-",
+                "lw": 4,
+                "alpha": 0.8,
+                "ms": 0,
+                "color": "#FAA61C",
+                "zorder": 2,
+            },
+            "Input Spectrum": {"ls": "-", "alpha": 0.4, "ms": 0, "color": "#1E317A", "zorder": 2.1},
+            "Best Fit Atlas": {"color": "k", "ls": "-", "ms": 0, "zorder": 2.2},
+        }
+
+        fit_plot = XYData(
+            xlabel="Wavelength [nm]",
+            ylabel="Signal",
+            series_data=fit_series,
+            plot_kwargs=fit_plot_kwargs,
+            sort_series=False,
+        )
+
+        residuals_series = {
+            "Residuals": FloatSeriesData(
+                x_values=tuple(best_fit_wave_list),
+                y_values=tuple(residuals_list),
+            )
+        }
+        residuals_plot_kwargs = {"Residuals": {"ls": "-", "color": "k", "ms": 0}}
+
+        y_min = float(np.nanpercentile(residuals_list, 2))
+        y_max = float(np.nanpercentile(residuals_list, 98))
+        y_range = y_max - y_min
+        y_min -= 0.1 * y_range
+        y_max += 0.1 * y_range
+
+        residuals_plot = XYData(
+            xlabel="Wavelength [nm]",
+            ylabel=r"$\frac{\mathrm{Obs - Atlas}}{\mathrm{Obs}}$",
+            series_data=residuals_series,
+            plot_kwargs=residuals_plot_kwargs,
+            ylim=(y_min, y_max),
+        )
+
+        plot_list = [fit_plot, residuals_plot]
+        height_ratios = [1.5, 1.0]
+        if weights is not None:
+            weight_series = {
+                "Weights": FloatSeriesData(
+                    x_values=tuple(best_fit_wave_list),
+                    y_values=tuple(weights),
+                )
+            }
+            weight_plot_kwargs = {"Weights": {"ls": "-", "color": "k", "ms": 0}}
+            weight_plot = XYData(
+                xlabel="Wavelength [nm]",
+                ylabel="Fit Weights",
+                series_data=weight_series,
+                plot_kwargs=weight_plot_kwargs,
+            )
+            plot_list.append(weight_plot)
+            height_ratios.append(1.0)
+
+        full_plot = MultiPlotData(
+            top_to_bottom_plot_list=plot_list,
+            match_x_axes=True,
+            no_gap=True,
+            top_to_bottom_height_ratios=height_ratios,
+        )
+
+        metric = QualityMetric(
+            name="Wavelength Calibration Results",
+            description="These plots show the wavelength solution computed based on fits to a Solar FTS atlas. "
+            "The top plot shows the input and best-fit spectra along with the best-fit atlas, which is "
+            "a combination of Solar and Telluric spectra. The bottom plot shows the fit residuals.",
+            metric_code=MetricCode.wavecal_fit,
+            multi_plot_data=full_plot,
+        )
+
+        self.write(metric, tags=Tag.quality("GENERIC"), encoder=basemodel_encoder)

{dkist_processing_common-14.3.6 → dkist_processing_common-14.4.0}/dkist_processing_common/tasks/mixin/quality/_metrics.py

@@ -678,144 +678,3 @@ class _PolcalQualityMixin:
         base_str += " bins."
 
         return base_str
-
-
-class _WavecalQualityMixin:
-    """Mixin class supporting the recording and building of wavecal-related metrics."""
-
-    def quality_store_wavecal_results(
-        self,
-        *,
-        input_wavelength: u.Quantity,
-        input_spectrum: np.ndarray,
-        fit_result: FitResult,
-        weights: None | np.ndarray = None,
-    ):
-        """
-        Store the results of a wavelength solution fit.
-
-        Namely, save the:
-
-        * Input spectrum and wavelength
-        * Best-fit combined atlas spectrum
-        * Best-fit wavelength vector
-        * Fit residuals
-
-        Note that the residuals are the *unweighed* residuals.
-        """
-        weight_data = np.ones(input_wavelength.size) if weights is None else weights
-        prepared_weights = fit_result.prepared_weights
-        residuals = fit_result.minimizer_result.residual / prepared_weights
-        residuals[~np.isfinite(residuals)] = 0.0
-        normalized_residuals = residuals / input_spectrum
-
-        best_fit_atlas = fit_result.best_fit_atlas
-        best_fit_wavelength = fit_result.best_fit_wavelength_vector
-
-        finite_idx = (
-            np.isfinite(input_wavelength)
-            * np.isfinite(input_spectrum)
-            * np.isfinite(best_fit_wavelength)
-            * np.isfinite(best_fit_atlas)
-            * np.isfinite(normalized_residuals)
-            * np.isfinite(weight_data)
-        )
-
-        data = {
-            "input_wavelength_nm": input_wavelength.to_value(u.nm)[finite_idx].tolist(),
-            "input_spectrum": input_spectrum[finite_idx].tolist(),
-            "best_fit_wavelength_nm": best_fit_wavelength[finite_idx].tolist(),
-            "best_fit_atlas": best_fit_atlas[finite_idx].tolist(),
-            "normalized_residuals": normalized_residuals[finite_idx].tolist(),
-            "weights": None if weights is None else weight_data[finite_idx].tolist(),
-        }
-
-        self._record_values(values=data, tags=[Tag.quality(MetricCode.wavecal_fit)])
-
-    def quality_build_wavecal_results(self) -> dict:
-        """Build a ReportMetric containing a multi-pane plot showing the fit spectra and residuals."""
-        data = next(self.read(tags=[Tag.quality(MetricCode.wavecal_fit)], decoder=json_decoder))
-
-        input_wave_list = data["input_wavelength_nm"]
-        input_spectrum_list = data["input_spectrum"]
-        best_fit_wave_list = data["best_fit_wavelength_nm"]
-        best_fit_atlas_list = data["best_fit_atlas"]
-        residuals_list = data["normalized_residuals"]
-        weights = data["weights"]
-
-        fit_series = {
-            "Best Fit Observations": [best_fit_wave_list, input_spectrum_list],
-            "Input Spectrum": [input_wave_list, input_spectrum_list],
-            "Best Fit Atlas": [best_fit_wave_list, best_fit_atlas_list],
-        }
-
-        # Set the colors and zorder here manually because the JSON-ization of the quality data means we can't be sure of
-        # the order these will be plotted in and thus can't rely on the default color-cycler in `dkist-quality`.
-        fit_plot_kwargs = {
-            "Best Fit Observations": {
-                "ls": "-",
-                "lw": 4,
-                "alpha": 0.8,
-                "ms": 0,
-                "color": "#FAA61C",
-                "zorder": 2,
-            },
-            "Input Spectrum": {"ls": "-", "alpha": 0.4, "ms": 0, "color": "#1E317A", "zorder": 2.1},
-            "Best Fit Atlas": {"color": "k", "ls": "-", "ms": 0, "zorder": 2.2},
-        }
-
-        fit_plot = Plot2D(
-            xlabel="Wavelength [nm]",
-            ylabel="Signal",
-            series_data=fit_series,
-            plot_kwargs=fit_plot_kwargs,
-            sort_series=False,
-        )
-
-        residuals_series = {"Residuals": [best_fit_wave_list, residuals_list]}
-        residuals_plot_kwargs = {"Residuals": {"ls": "-", "color": "k", "ms": 0}}
-
-        y_min = np.nanpercentile(residuals_list, 2)
-        y_max = np.nanpercentile(residuals_list, 98)
-        y_range = y_max - y_min
-        y_min -= 0.1 * y_range
-        y_max += 0.1 * y_range
-        residuals_plot = Plot2D(
-            xlabel="Wavelength [nm]",
-            ylabel=r"$\frac{\mathrm{Obs - Atlas}}{\mathrm{Obs}}$",
-            series_data=residuals_series,
-            plot_kwargs=residuals_plot_kwargs,
-            ylim=(y_min, y_max),
-        )
-
-        plot_list = [fit_plot, residuals_plot]
-        height_ratios = [1.5, 1.0]
-        if weights is not None:
-            weight_series = {"Weights": [best_fit_wave_list, weights]}
-            weight_plot_kwargs = {"Weights": {"ls": "-", "color": "k", "ms": 0}}
-            weight_plot = Plot2D(
-                xlabel="Wavelength [nm]",
-                ylabel="Fit Weights",
-                series_data=weight_series,
-                plot_kwargs=weight_plot_kwargs,
-            )
-            plot_list.append(weight_plot)
-            height_ratios.append(1.0)
-
-        full_plot = VerticalMultiPanePlot2D(
-            top_to_bottom_plot_list=plot_list,
-            match_x_axes=True,
-            no_gap=True,
-            top_to_bottom_height_ratios=height_ratios,
-        )
-
-        metric = ReportMetric(
-            name="Wavelength Calibration Results",
-            description="These plots show the wavelength solution computed based on fits to a Solar FTS atlas. "
-            "The top plot shows the input and best-fit spectra along with the best-fit atlas, which is "
-            "a combination of Solar and Telluric spectra. The bottom plot shows the fit residuals.",
-            metric_code=MetricCode.wavecal_fit,
-            multi_plot_data=full_plot,
-        )
-
-        return metric.model_dump()