dkist-processing-common 10.8.4rc1__tar.gz → 11.0.0__tar.gz

{dkist_processing_common-10.8.4rc1 → dkist_processing_common-11.0.0}/CHANGELOG.rst

@@ -1,3 +1,35 @@
+v11.0.0 (2025-07-02)
+====================
+
+Features
+--------
+
+- Move `location_of_dkist` from the `WriteL1` task to its own module (`~dkist_processing_common.models.dkist_location`).
+  Also make it a constant variable instead of a function. (`#256 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/256>`__)
+- `Stems` that only match a specific task types can now check against a list of task types.
+  This replaces the `ip_task_type` kwarg with `ip_task_types` (which can still be a single string, if desired.) (`#257 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/257>`__)
+- Add ability to store and build a quality metric showing the results of wavelength calibration. (`#259 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/259>`__)
+
+
+v10.9.0 (2025-06-02)
+====================
+
+Features
+--------
+
+- Add two new codecs:  Basemodel codecs are used for encoding and decoding Pydantic BaseModel objects.  For decoding, the intended model
+  is passed to the decoder through a keyword argument in the task read method.  Array codecs are used for encoding and decoding numpy
+  arrays similar to the standard np.load() and np.save(), but with the task tag-based write method. (`#235 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/235>`__)
+
+
+Misc
+----
+
+- Remove the input_dataset mixin and replace it with input_dataset Pydantic BaseModel models. (`#235 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/235>`__)
+- Change the behavior of ParameterBase such that it takes the task scratch as an argument to provide access to the
+  parameter document and parameters that are files.  This behavior replaces the input dataset mixin parameter read method. (`#235 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/235>`__)
+
+
 v10.8.3 (2025-05-28)
 ====================
 

{dkist_processing_common-10.8.4rc1 → dkist_processing_common-11.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-common
-Version: 10.8.4rc1
+Version: 11.0.0
 Summary: Common task classes used by the DKIST science data processing pipelines
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause
@@ -21,6 +21,7 @@ Requires-Dist: dkist-processing-core==5.1.1
 Requires-Dist: dkist-processing-pac<4.0,>=3.1
 Requires-Dist: dkist-service-configuration<3.0,>=2.0.2
 Requires-Dist: dkist-spectral-lines<4.0,>=3.0.0
+Requires-Dist: solar-wavelength-calibration<2.0,>=1.0
 Requires-Dist: globus-sdk>=3.12.0
 Requires-Dist: gqlclient[pydantic]==1.2.3
 Requires-Dist: sqids==0.5.1
@@ -60,7 +61,7 @@ Requires-Dist: dkist-inventory<2.0,>=1.6.0; extra == "inventory"
 Provides-Extra: asdf
 Requires-Dist: dkist-inventory[asdf]<2.0,>=1.6.0; extra == "asdf"
 Provides-Extra: quality
-Requires-Dist: dkist-quality<2.0,>=1.2.1; extra == "quality"
+Requires-Dist: dkist-quality<2.0,>=1.3.0; extra == "quality"
 
 dkist-processing-common
 =======================

dkist_processing_common-11.0.0/dkist_processing_common/models/dkist_location.py

@@ -0,0 +1,27 @@
+"""Return hard-coded EarthLocation of the DKIST.
+
+Cartesian geocentric coordinates of DKIST on Earth as retrieved from
+https://github.com/astropy/astropy-data/blob/gh-pages/coordinates/sites.json#L838
+"""
+import astropy.units as u
+from astropy.coordinates import EarthLocation
+
+
+_dkist_site_info = {
+    "aliases": ["DKIST", "ATST"],
+    "name": "Daniel K. Inouye Solar Telescope",
+    "elevation": 3067,
+    "elevation_unit": "meter",
+    "latitude": 20.7067,
+    "latitude_unit": "degree",
+    "longitude": 203.7436,
+    "longitude_unit": "degree",
+    "timezone": "US/Hawaii",
+    "source": "DKIST website: https://www.nso.edu/telescopes/dki-solar-telescope/",
+}
+
+location_of_dkist: EarthLocation = EarthLocation.from_geodetic(
+    _dkist_site_info["longitude"] * u.Unit(_dkist_site_info["longitude_unit"]),
+    _dkist_site_info["latitude"] * u.Unit(_dkist_site_info["latitude_unit"]),
+    _dkist_site_info["elevation"] * u.Unit(_dkist_site_info["elevation_unit"]),
+)

{dkist_processing_common-10.8.4rc1 → dkist_processing_common-11.0.0}/dkist_processing_common/models/metric_code.py

@@ -23,3 +23,4 @@ class MetricCode(StrEnum):
     range = "RANGE"
     sensitivity = "SENSITIVITY"
     task_types = "TASK_TYPES"
+    wavecal_fit = "WAVECAL_FIT"

{dkist_processing_common-10.8.4rc1 → dkist_processing_common-11.0.0}/dkist_processing_common/models/quality.py

@@ -2,6 +2,9 @@
 from typing import Any
 
 from pydantic import BaseModel
+from pydantic import Field
+from pydantic import field_validator
+from pydantic_core.core_schema import ValidationInfo
 
 
 class Plot2D(BaseModel):
@@ -13,6 +16,50 @@ class Plot2D(BaseModel):
     series_name: str | None = None
     ylabel_horizontal: bool = False
     ylim: tuple[float, float] | None = None
+    plot_kwargs: dict[str, dict[str, Any]] = Field(default_factory=dict)
+    sort_series: bool = True
+
+
+class VerticalMultiPanePlot2D(BaseModel):
+    """
+    Support class to hold a multi-pane plot with plots stacked vertically.
+
+    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 `Plot2D` objects.
+    """
+
+    top_to_bottom_plot_list: list[Plot2D]
+    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 SimpleTable(BaseModel):
@@ -57,11 +104,7 @@ class PlotRaincloud(BaseModel):
 
 
 class ReportMetric(BaseModel):
-    """
-    A Quality Report is made up of a list of metrics with the schema defined by this class.
-
-    Additionally, this class can produce a Flowable or List of Flowables to be render the metric in the PDF Report
-    """
+    """A Quality Report is made up of a list of metrics with the schema defined by this class."""
 
     name: str
     description: str
@@ -69,6 +112,7 @@ class ReportMetric(BaseModel):
     facet: str | None = None
     statement: str | list[str] | None = None
     plot_data: Plot2D | list[Plot2D] | None = None
+    vertical_multi_pane_plot_data: VerticalMultiPanePlot2D | None = None
     histogram_data: PlotHistogram | list[PlotHistogram] | None = None
     table_data: SimpleTable | list[SimpleTable] | None = None
     modmat_data: ModulationMatrixHistograms | None = None

{dkist_processing_common-10.8.4rc1 → dkist_processing_common-11.0.0}/dkist_processing_common/parsers/dsps_repeat.py

@@ -17,7 +17,7 @@ class TotalDspsRepeatsBud(TaskUniqueBud):
         super().__init__(
             constant_name=BudName.num_dsps_repeats.value,
             metadata_key="num_dsps_repeats",
-            ip_task_type=TaskName.observe.value,
+            ip_task_types=TaskName.observe.value,
         )
 
 

{dkist_processing_common-10.8.4rc1 → dkist_processing_common-11.0.0}/dkist_processing_common/parsers/id_bud.py

@@ -15,7 +15,7 @@ class IdBud(TaskUniqueBud):
         super().__init__(
             constant_name=constant_name,
             metadata_key=metadata_key,
-            ip_task_type=TaskName.observe.value,
+            ip_task_types=TaskName.observe.value,
         )
 
 

{dkist_processing_common-10.8.4rc1 → dkist_processing_common-11.0.0}/dkist_processing_common/parsers/near_bud.py

@@ -74,7 +74,7 @@ class NearFloatBud(Stem):
 
 class TaskNearFloatBud(NearFloatBud):
     """
-    Subclass of `NearFloatBud` that only considers objects that have a specific task type.
+    Subclass of `NearFloatBud` that only considers objects that have specific task types.
 
     Parameters
     ----------
@@ -84,8 +84,8 @@ class TaskNearFloatBud(NearFloatBud):
     metadata_key
         The metadata key associated with the constant
 
-    ip_task_type
-        Only consider objects whose parsed header IP task type matches this string
+    ip_task_types
+        Only consider objects whose parsed header IP task type matches a string in this list
 
     task_type_parsing_function
         The function used to convert a header into an IP task type
@@ -98,7 +98,7 @@ class TaskNearFloatBud(NearFloatBud):
         self,
         constant_name: str,
         metadata_key: str,
-        ip_task_type: str,
+        ip_task_types: str | list[str],
         tolerance: float,
         task_type_parsing_function: Callable = passthrough_header_ip_task,
     ):
@@ -106,14 +106,16 @@ class TaskNearFloatBud(NearFloatBud):
             constant_name=constant_name, metadata_key=metadata_key, tolerance=tolerance
         )
 
-        self.ip_task_type = ip_task_type.casefold()
+        if isinstance(ip_task_types, str):
+            ip_task_types = [ip_task_types]
+        self.ip_task_types = [task.casefold() for task in ip_task_types]
         self.parsing_function = task_type_parsing_function
 
     def setter(self, fits_obj: L0FitsAccess):
         """Ingest an object only if its parsed IP task type matches what's desired."""
         task = self.parsing_function(fits_obj)
 
-        if task.casefold() == self.ip_task_type:
+        if task.casefold() in self.ip_task_types:
             return super().setter(fits_obj)
 
         return SpilledDirt

{dkist_processing_common-10.8.4rc1 → dkist_processing_common-11.0.0}/dkist_processing_common/parsers/retarder.py

@@ -20,7 +20,7 @@ class RetarderNameBud(TaskUniqueBud):
         super().__init__(
             constant_name=BudName.retarder_name.value,
             metadata_key="gos_retarder_status",
-            ip_task_type=TaskName.polcal.value,
+            ip_task_types=TaskName.polcal.value,
         )
 
     def getter(self, key) -> str:

{dkist_processing_common-10.8.4rc1 → dkist_processing_common-11.0.0}/dkist_processing_common/parsers/time.py

@@ -29,7 +29,7 @@ class ObsIpStartTimeBud(TaskUniqueBud):
         super().__init__(
             constant_name=BudName.obs_ip_start_time.value,
             metadata_key="ip_start_time",
-            ip_task_type=TaskName.observe.value,
+            ip_task_types=TaskName.observe.value,
         )
 
 
@@ -187,31 +187,48 @@ class ReadoutExpTimeFlower(TimeFlowerBase):
 
 class TaskTimeBudBase(Stem):
     """
-    Base class for making time-related buds that are computed for a specific task type.
+    Base class for making time-related buds that are computed for specific task types.
 
     By "time-related" we mean values that generally need rounding when ingested into the database.
 
     Complicated parsing of the header into a task type can be achieved by passing in a different
     header task parsing function.
+
+    Parameters
+    ----------
+    constant_name
+        The name for the constant to be defined
+
+    metadata_key
+        The metadata key associated with the constant
+
+    ip_task_types
+        Only consider objects whose parsed header IP task type matches a string in this list
+
+    header_task_parsing_func
+        The function used to convert a header into an IP task type
     """
 
     def __init__(
         self,
         stem_name: str,
         metadata_key: str,
-        ip_task_type: str,
+        ip_task_types: str | list[str],
         header_task_parsing_func: Callable = passthrough_header_ip_task,
     ):
         super().__init__(stem_name=stem_name)
+
+        if isinstance(ip_task_types, str):
+            ip_task_types = [ip_task_types]
         self.metadata_key = metadata_key
-        self.ip_task_type = ip_task_type
+        self.ip_task_types = [task.casefold() for task in ip_task_types]
         self.header_parsing_function = header_task_parsing_func
 
     def setter(self, fits_obj: L0FitsAccess):
         """Return the desired metadata key only if the parsed task type matches the Bud's task type."""
         task = self.header_parsing_function(fits_obj)
 
-        if task.casefold() == self.ip_task_type.casefold():
+        if task.casefold() in self.ip_task_types:
             raw_value = getattr(fits_obj, self.metadata_key)
             return round(raw_value, EXP_TIME_ROUND_DIGITS)
 
@@ -229,13 +246,13 @@ class TaskExposureTimesBud(TaskTimeBudBase):
     def __init__(
         self,
         stem_name: str,
-        ip_task_type: str,
+        ip_task_types: str | list[str],
         header_task_parsing_func: Callable = passthrough_header_ip_task,
     ):
         super().__init__(
             stem_name=stem_name,
             metadata_key="fpa_exposure_time_ms",
-            ip_task_type=ip_task_type,
+            ip_task_types=ip_task_types,
             header_task_parsing_func=header_task_parsing_func,
         )
 
@@ -246,12 +263,12 @@ class TaskReadoutExpTimesBud(TaskTimeBudBase):
     def __init__(
         self,
         stem_name: str,
-        ip_task_type: str,
+        ip_task_types: str | list[str],
         header_task_parsing_func: Callable = passthrough_header_ip_task,
     ):
         super().__init__(
             stem_name=stem_name,
             metadata_key="sensor_readout_exposure_time_ms",
-            ip_task_type=ip_task_type,
+            ip_task_types=ip_task_types,
             header_task_parsing_func=header_task_parsing_func,
         )

{dkist_processing_common-10.8.4rc1 → dkist_processing_common-11.0.0}/dkist_processing_common/parsers/unique_bud.py

@@ -64,7 +64,7 @@ class UniqueBud(Stem):
 
 class TaskUniqueBud(UniqueBud):
     """
-    Subclass of `UniqueBud` that only considers objects that have a specific task type.
+    Subclass of `UniqueBud` that only considers objects that have specific task types.
 
     Parameters
     ----------
@@ -74,8 +74,8 @@ class TaskUniqueBud(UniqueBud):
     metadata_key
         The metadata key associated with the constant
 
-    ip_task_type
-        Only consider objects whose parsed header IP task type matches this string
+    ip_task_types
+        Only consider objects whose parsed header IP task type matches a string in this list
 
     task_type_parsing_function
         The function used to convert a header into an IP task type
@@ -85,19 +85,21 @@ class TaskUniqueBud(UniqueBud):
         self,
         constant_name: str,
         metadata_key: str,
-        ip_task_type: str,
+        ip_task_types: str | list[str],
         task_type_parsing_function: Callable = passthrough_header_ip_task,
     ):
         super().__init__(constant_name=constant_name, metadata_key=metadata_key)
 
-        self.ip_task_type = ip_task_type.casefold()
+        if isinstance(ip_task_types, str):
+            ip_task_types = [ip_task_types]
+        self.ip_task_types = [task.casefold() for task in ip_task_types]
         self.parsing_function = task_type_parsing_function
 
     def setter(self, fits_obj: L0FitsAccess):
         """Ingest an object only if its parsed IP task type matches what's desired."""
         task = self.parsing_function(fits_obj)
 
-        if task.casefold() == self.ip_task_type:
+        if task.casefold() in self.ip_task_types:
             return super().setter(fits_obj)
 
         return SpilledDirt

{dkist_processing_common-10.8.4rc1 → dkist_processing_common-11.0.0}/dkist_processing_common/parsers/wavelength.py

@@ -11,5 +11,5 @@ class ObserveWavelengthBud(TaskUniqueBud):
         super().__init__(
             constant_name=BudName.wavelength.value,
             metadata_key="wavelength",
-            ip_task_type=TaskName.observe.value,
+            ip_task_types=TaskName.observe.value,
         )

{dkist_processing_common-10.8.4rc1 → dkist_processing_common-11.0.0}/dkist_processing_common/tasks/mixin/quality/_base.py

@@ -11,10 +11,15 @@ from dkist_processing_common.tasks.mixin.quality._metrics import _PolcalQualityM
 from dkist_processing_common.tasks.mixin.quality._metrics import _SimplePlotQualityMixin
 from dkist_processing_common.tasks.mixin.quality._metrics import _SimpleQualityMixin
 from dkist_processing_common.tasks.mixin.quality._metrics import _TableQualityMixin
+from dkist_processing_common.tasks.mixin.quality._metrics import _WavecalQualityMixin
 
 
 class QualityMixin(
-    _SimpleQualityMixin, _SimplePlotQualityMixin, _TableQualityMixin, _PolcalQualityMixin
+    _SimpleQualityMixin,
+    _SimplePlotQualityMixin,
+    _TableQualityMixin,
+    _PolcalQualityMixin,
+    _WavecalQualityMixin,
 ):
     """Mixin class supporting the generation of the quality reports."""
 
@@ -81,6 +86,7 @@ class QualityMixin(
             "HISTORICAL": self.quality_build_historical,
             "AO_STATUS": self.quality_build_ao_status,
             "RANGE": self.quality_build_range,
+            "WAVECAL_FIT": self.quality_build_wavecal_results,
         }
 
     @property

{dkist_processing_common-10.8.4rc1 → dkist_processing_common-11.0.0}/dkist_processing_common/tasks/mixin/quality/_metrics.py

@@ -12,14 +12,18 @@ from typing import Any
 from typing import Iterable
 from typing import Literal
 
+import astropy.units as u
 import numpy as np
+from astropy.wcs import WCS
 from dkist_processing_pac.fitter.fitter_parameters import CU_PARAMS
 from dkist_processing_pac.fitter.fitter_parameters import GLOBAL_PARAMS
 from dkist_processing_pac.fitter.fitter_parameters import TELESCOPE_PARAMS
 from dkist_processing_pac.fitter.fitting_core import compare_I
 from dkist_processing_pac.fitter.polcal_fitter import PolcalFitter
 from pandas import DataFrame
+from solar_wavelength_calibration.fitter.wavelength_fitter import FitResult
 
+from dkist_processing_common.codecs.json import json_decoder
 from dkist_processing_common.models.fried_parameter import r0_valid
 from dkist_processing_common.models.metric_code import MetricCode
 from dkist_processing_common.models.quality import EfficiencyHistograms
@@ -29,6 +33,7 @@ from dkist_processing_common.models.quality import PlotHistogram
 from dkist_processing_common.models.quality import PlotRaincloud
 from dkist_processing_common.models.quality import ReportMetric
 from dkist_processing_common.models.quality import SimpleTable
+from dkist_processing_common.models.quality import VerticalMultiPanePlot2D
 from dkist_processing_common.models.tags import Tag
 
 logger = logging.getLogger(__name__)
@@ -1324,3 +1329,127 @@ 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 = np.sqrt(weight_data / np.sum(weight_data))
+        residuals = fit_result.minimizer_result.residual / prepared_weights
+        residuals[~np.isfinite(residuals)] = 0.0
+        best_fit_atlas = input_spectrum - residuals
+        normalized_residuals = residuals / input_spectrum
+
+        best_fit_header = fit_result.wavelength_parameters.to_header(axis_num=1)
+        wcs = WCS(best_fit_header)
+        best_fit_wavelength = wcs.spectral.pixel_to_world(np.arange(input_spectrum.size))
+
+        data = {
+            "input_wavelength_nm": input_wavelength.to_value(u.nm).tolist(),
+            "input_spectrum": input_spectrum.tolist(),
+            "best_fit_wavelength_nm": best_fit_wavelength.to_value(u.nm).tolist(),
+            "best_fit_atlas": best_fit_atlas.tolist(),
+            "normalized_residuals": normalized_residuals.tolist(),
+            "weights": None if weights is None else weight_data.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],
+        }
+        fit_plot_kwargs = {
+            "Best Fit Observations": {"ls": "-", "lw": 4, "alpha": 0.8, "ms": 0},
+            "Input Spectrum": {"ls": "-", "alpha": 0.4, "ms": 0},
+            "Best Fit Atlas": {"color": "k", "ls": "-", "ms": 0},
+        }
+
+        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,
+            vertical_multi_pane_plot_data=full_plot,
+        )
+
+        return metric.model_dump()

{dkist_processing_common-10.8.4rc1 → dkist_processing_common-11.0.0}/dkist_processing_common/tasks/parse_l0_input_data.py

@@ -20,7 +20,6 @@ that makes the rest of the pipeline easy to write.
 In other words, we can find exactly the frame we need (tags) and, once we have it, we never need to look
 at a different frame to get information (constants).
 """
-import json
 import logging
 from abc import ABC
 from abc import abstractmethod
@@ -70,8 +69,10 @@ def default_constant_bud_factory() -> list[S]:
         MaximumCadenceBud(),
         MinimumCadenceBud(),
         VarianceCadenceBud(),
-        TaskExposureTimesBud(stem_name=BudName.dark_exposure_times.value, ip_task_type="dark"),
-        TaskReadoutExpTimesBud(stem_name=BudName.dark_readout_exp_times.value, ip_task_type="dark"),
+        TaskExposureTimesBud(stem_name=BudName.dark_exposure_times.value, ip_task_types="dark"),
+        TaskReadoutExpTimesBud(
+            stem_name=BudName.dark_readout_exp_times.value, ip_task_types="dark"
+        ),
     ]