dkist-processing-cryonirsp 1.4.20__py3-none-any.whl → 1.14.9rc1__py3-none-any.whl

changelog/232.misc.rst

@@ -0,0 +1 @@
+Update dkist-processing-common to add a new constant for the dark number of frames per FPA.

dkist_processing_cryonirsp/__init__.py

@@ -1,4 +1,5 @@
 """Init."""
+
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version
 

dkist_processing_cryonirsp/codecs/fits.py

@@ -1,4 +1,5 @@
 """Encoders and decoders for writing and reading Cryo-NIRSP FITS files."""
+
 from pathlib import Path
 
 import numpy as np

dkist_processing_cryonirsp/config.py

@@ -1,11 +1,15 @@
 """Configuration for the dkist-processing-cryonirsp package and the logging thereof."""
+
 from dkist_processing_common.config import DKISTProcessingCommonConfiguration
+from pydantic import Field
 
 
 class DKISTProcessingCryoNIRSPConfigurations(DKISTProcessingCommonConfiguration):
     """Configurations custom to the dkist-processing-cryonirsp package."""
 
-    pass  # nothing custom yet
+    fts_atlas_data_dir: str | None = Field(
+        default=None, description="Common cached directory for a downloaded FTS Atlas."
+    )
 
 
 dkist_processing_cryonirsp_configurations = DKISTProcessingCryoNIRSPConfigurations()

dkist_processing_cryonirsp/models/beam_boundaries.py

@@ -1,4 +1,5 @@
 """Beam boundary class."""
+
 from dataclasses import dataclass
 
 import numpy as np

dkist_processing_cryonirsp/models/constants.py

@@ -1,15 +1,16 @@
 """CryoNIRSP additions to common constants."""
-from enum import Enum
+
+from enum import StrEnum
 from enum import unique
 
-from dkist_processing_common.models.constants import BudName
+import astropy.units as u
 from dkist_processing_common.models.constants import ConstantsBase
 
 from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
 
 
 @unique
-class CryonirspBudName(Enum):
+class CryonirspBudName(StrEnum):
     """Names to be used for CryoNIRSP buds."""
 
     arm_id = "ARM_ID"
@@ -18,8 +19,6 @@ class CryonirspBudName(Enum):
     num_map_scans = "NUM_MAP_SCANS"
     num_modstates = "NUM_MODSTATES"
     wavelength = "WAVELENGTH"
-    wave_min = "WAVE_MIN"
-    wave_max = "WAVE_MAX"
     grating_position_deg = "GRATING_POSITION_DEG"
     grating_littrow_angle_deg = "GRATING_LITTROW_ANGLE_DEG"
     grating_constant = "GRATING_CONSTANT"
@@ -50,10 +49,12 @@ class CryonirspBudName(Enum):
     roi_1_size_x = "ROI_1_SIZE_X"
     roi_1_size_y = "ROI_1_SIZE_Y"
     optical_density_filter_picky_bud = "OPTICAL_DENSITY_FILTER_PICKY_BUD"
-    solar_gain_ip_start_time = "SOLAR_GAIN_IP_START_TIME"
+    solar_gain_start_time = "SOLAR_GAIN_START_TIME"
     gain_frame_type_list = "GAIN_FRAME_TYPE_LIST"
     lamp_gain_frame_type_list = "LAMP_GAIN_FRAME_TYPE_LIST"
     solar_gain_frame_type_list = "SOLAR_GAIN_FRAME_TYPE_LIST"
+    center_wavelength = "CENTER_WAVELENGTH"
+    slit_width = "SLIT_WIDTH"
 
 
 class CryonirspConstants(ConstantsBase):
@@ -88,19 +89,9 @@ class CryonirspConstants(ConstantsBase):
         return self._db_dict[CryonirspBudName.wavelength.value]
 
     @property
-    def wave_min(self) -> float:
-        """Wavelength minimum."""
-        return self._db_dict[CryonirspBudName.wave_min.value]
-
-    @property
-    def wave_max(self) -> float:
-        """Wavelength maximum."""
-        return self._db_dict[CryonirspBudName.wave_max.value]
-
-    @property
-    def solar_gain_ip_start_time(self) -> str:
-        """Solar gain IP start time."""
-        return self._db_dict[CryonirspBudName.solar_gain_ip_start_time.value]
+    def solar_gain_start_time(self) -> str:
+        """Solar gain start time."""
+        return self._db_dict[CryonirspBudName.solar_gain_start_time.value]
 
     @property
     def grating_position_deg(self) -> float:
@@ -112,10 +103,20 @@ class CryonirspConstants(ConstantsBase):
         """Grating littrow angle (deg)."""
         return self._db_dict[CryonirspBudName.grating_littrow_angle_deg.value]
 
+    @property
+    def center_wavelength(self) -> float:
+        """Center wavelength of the selected filter (nm)."""
+        return self._db_dict[CryonirspBudName.center_wavelength.value]
+
+    @property
+    def slit_width(self) -> float:
+        """Physical width of the selected slit (um)."""
+        return self._db_dict[CryonirspBudName.slit_width.value]
+
     @property
     def grating_constant(self) -> float:
         """Grating constant."""
-        return self._db_dict[CryonirspBudName.grating_constant.value]
+        return self._db_dict[CryonirspBudName.grating_constant.value] / u.mm
 
     @property
     def camera_readout_mode(self) -> str:
@@ -214,16 +215,6 @@ class CryonirspConstants(ConstantsBase):
         conditions = [ExposureConditions(*item) for item in raw_conditions]
         return conditions
 
-    @property
-    def num_modstates(self) -> int:
-        """Find the number of modulation states."""
-        return self._db_dict[CryonirspBudName.num_modstates.value]
-
-    @property
-    def num_cs_steps(self) -> int:
-        """Find the number of calibration sequence steps."""
-        return self._db_dict[BudName.num_cs_steps.value]
-
     @property
     def stokes_I_list(self) -> [str]:
         """List containing only the Stokes-I parameter."""
@@ -236,6 +227,16 @@ class CryonirspConstants(ConstantsBase):
             CryonirspBudName.modulator_spin_mode.value
         ] in ["Continuous", "Stepped"]
 
+    @property
+    def pac_init_set(self):
+        """Return the label for the initial set of parameter values used when fitting demodulation matrices."""
+        retarder_name = self.retarder_name
+        match retarder_name:
+            case "SiO2 OC":
+                return "OCCal_VIS"
+            case _:
+                raise ValueError(f"No init set known for {retarder_name = }")
+
     @property
     def axis_1_type(self) -> str:
         """Find the type of the first array axis."""

dkist_processing_cryonirsp/models/exposure_conditions.py

@@ -1,16 +1,17 @@
 """Support classes for exposure conditions."""
-from collections import namedtuple
+
 from enum import StrEnum
+from typing import NamedTuple
 
 # Number of digits used to round the exposure when creating the ExposureConditions tuple in fits_access
 CRYO_EXP_TIME_ROUND_DIGITS: int = 3
 
-"""Base class to hold a tuple of exposure time and filter name."""
-ExposureConditionsBase = namedtuple("ExposureConditions", ["exposure_time", "filter_name"])
 
+class ExposureConditions(NamedTuple):
+    """Named tuple to hold exposure time and filter name."""
 
-class ExposureConditions(ExposureConditionsBase):
-    """Define str to make tags look reasonable."""
+    exposure_time: float
+    filter_name: str
 
     def __str__(self):
         return f"{self.exposure_time}_{self.filter_name}"

dkist_processing_cryonirsp/models/fits_access.py

@@ -0,0 +1,40 @@
+"""CryoNIRSP control of FITS key names and values."""
+
+from enum import StrEnum
+from enum import unique
+
+
+@unique
+class CryonirspMetadataKey(StrEnum):
+    """Controlled list of names for FITS metadata header keys."""
+
+    camera_readout_mode = "CNCAMMD"
+    curr_frame_in_ramp = "CNCNDR"
+    num_frames_in_ramp = "CNNNDR"
+    arm_id = "CNARMID"
+    roi_1_origin_x = "HWROI1OX"
+    roi_1_origin_y = "HWROI1OY"
+    roi_1_size_x = "HWROI1SX"
+    roi_1_size_y = "HWROI1SY"
+    filter_name = "CNFILTNP"
+    number_of_modulator_states = "CNMODNST"
+    modulator_state = "CNMODCST"
+    scan_step = "CNCURSCN"
+    num_scan_steps = "CNNUMSCN"
+    num_cn1_scan_steps = "CNP1DNSP"
+    num_cn2_scan_steps = "CNP2DNSP"
+    cn2_step_size = "CNP2DSS"
+    cn1_scan_step = "CNP1DCUR"
+    meas_num = "CNCMEAS"
+    num_meas = "CNNMEAS"
+    sub_repeat_num = "CNCSREP"
+    num_sub_repeats = "CNSUBREP"
+    modulator_spin_mode = "CNSPINMD"
+    axis_1_type = "CTYPE1"
+    axis_2_type = "CTYPE2"
+    axis_3_type = "CTYPE3"
+    grating_position_deg = "CNGRTPOS"
+    grating_littrow_angle_deg = "CNGRTLAT"
+    grating_constant = "CNGRTCON"
+    center_wavelength = "CNCENWAV"
+    slit_width = "CNSLITW"

dkist_processing_cryonirsp/models/parameters.py

@@ -1,4 +1,5 @@
 """CryoNIRSP calibration pipeline parameters."""
+
 from datetime import datetime
 from functools import cached_property
 
@@ -7,6 +8,7 @@ import numpy as np
 from dkist_processing_common.models.parameters import ParameterArmIdMixin
 from dkist_processing_common.models.parameters import ParameterBase
 from dkist_processing_common.models.parameters import ParameterWavelengthMixin
+from solar_wavelength_calibration import DownloadConfig
 
 from dkist_processing_cryonirsp.models.exposure_conditions import AllowableOpticalDensityFilterNames
 
@@ -82,11 +84,6 @@ class CryonirspParameters(ParameterBase, ParameterWavelengthMixin, ParameterArmI
         """Name of set of fitting flags to use during PAC Calibration Unit parameter fits."""
         return self._find_most_recent_past_value("cryonirsp_polcal_pac_fit_mode")
 
-    @property
-    def polcal_pac_init_set(self):
-        """Name of set of initial values for Calibration Unit parameter fit."""
-        return self._find_most_recent_past_value("cryonirsp_polcal_pac_init_set")
-
     @property
     def beam_boundaries_smoothing_disk_size(self) -> int:
         """Return the size of the smoothing disk (in pixels) to be used in the beam boundaries computation."""
@@ -141,8 +138,8 @@ class CryonirspParameters(ParameterBase, ParameterWavelengthMixin, ParameterArmI
     @cached_property
     def linearization_thresholds(self) -> np.ndarray:
         """Name of parameter associated with the linearization thresholds."""
-        param_dict = self._find_parameter_for_arm("cryonirsp_linearization_thresholds")
-        value = self._load_param_value_from_numpy_save(param_dict)
+        param_obj = self._find_parameter_for_arm("cryonirsp_linearization_thresholds")
+        value = self._load_param_value_from_numpy_save(param_obj=param_obj)
         # float64 data can blow up the memory required for linearization - convert to float32
         if np.issubdtype(value.dtype, np.float64):
             value = value.astype(np.float32, casting="same_kind")
@@ -272,24 +269,15 @@ class CryonirspParameters(ParameterBase, ParameterWavelengthMixin, ParameterArmI
         """Return the CryoNIRSP pixel pitch."""
         return self._find_most_recent_past_value("cryonirsp_pixel_pitch_micron") * u.micron
 
-    @cached_property
-    def solar_atlas(self) -> np.ndarray:
-        """Solar reference atlas.
-
-        Contains two arrays:
-        - wavelength in nanometers
-        - transmission at given wavelength
-        """
-        param_dict = self._find_most_recent_past_value("cryonirsp_solar_atlas")
-        return self._load_param_value_from_numpy_save(param_dict)
+    @property
+    def wavecal_atlas_download_config(self) -> DownloadConfig:
+        """Define the `~solar_wavelength_calibration.DownloadConfig` used to grab the Solar atlas used for wavelength calibration."""
+        config_dict = self._find_most_recent_past_value("cryonirsp_wavecal_atlas_download_config")
+        return DownloadConfig.model_validate(config_dict)
 
     @cached_property
-    def telluric_atlas(self) -> np.ndarray:
-        """Telluric reference atlas.
-
-        Contains two arrays:
-        - wavelength in nanometers
-        - transmission at given wavelength
-        """
-        param_dict = self._find_most_recent_past_value("cryonirsp_telluric_atlas")
-        return self._load_param_value_from_numpy_save(param_dict)
+    def wavecal_fraction_of_unweighted_edge_pixels(self) -> int:
+        """Return the fraction of edge pixels to weight to zero during the wavelength calibration."""
+        return self._find_most_recent_past_value(
+            "cryonirsp_wavecal_fraction_of_unweighted_edge_pixels"
+        )

dkist_processing_cryonirsp/models/tags.py

@@ -1,4 +1,5 @@
 """CryoNIRSP tags."""
+
 from enum import Enum
 
 from dkist_processing_common.models.tags import StemName

dkist_processing_cryonirsp/models/task_name.py

@@ -1,4 +1,5 @@
 """List of intermediate task names."""
+
 from enum import Enum
 
 

dkist_processing_cryonirsp/parsers/check_for_gains.py

@@ -1,4 +1,5 @@
 """Pickybud to check for lamp gain and solar gain frames."""
+
 from typing import Hashable
 from typing import Type
 

dkist_processing_cryonirsp/parsers/cryonirsp_l0_fits_access.py

@@ -1,10 +1,12 @@
 """CryoNIRSP FITS access for L0 data."""
+
 import numpy as np
 from astropy.io import fits
 from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
 
 from dkist_processing_cryonirsp.models.exposure_conditions import CRYO_EXP_TIME_ROUND_DIGITS
 from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
+from dkist_processing_cryonirsp.models.fits_access import CryonirspMetadataKey
 
 
 class CryonirspRampFitsAccess(L0FitsAccess):
@@ -33,16 +35,15 @@ class CryonirspRampFitsAccess(L0FitsAccess):
     ):
         super().__init__(hdu=hdu, name=name, auto_squeeze=auto_squeeze)
 
-        self.camera_readout_mode = self.header["CNCAMMD"]
-        self.curr_frame_in_ramp: int = self.header["CNCNDR"]
-        self.num_frames_in_ramp: int = self.header["CNNNDR"]
-        self.arm_id: str = self.header["CNARMID"]
-        self.filter_name = self.header["CNFILTNP"].upper()
-        self.roi_1_origin_x = self.header["HWROI1OX"]
-        self.roi_1_origin_y = self.header["HWROI1OY"]
-        self.roi_1_size_x = self.header["HWROI1SX"]
-        self.roi_1_size_y = self.header["HWROI1SY"]
-        self.obs_ip_start_time = self.header["DKIST011"]
+        self.camera_readout_mode = self.header[CryonirspMetadataKey.camera_readout_mode]
+        self.curr_frame_in_ramp: int = self.header[CryonirspMetadataKey.curr_frame_in_ramp]
+        self.num_frames_in_ramp: int = self.header[CryonirspMetadataKey.num_frames_in_ramp]
+        self.arm_id: str = self.header[CryonirspMetadataKey.arm_id]
+        self.filter_name = self.header[CryonirspMetadataKey.filter_name].upper()
+        self.roi_1_origin_x = self.header[CryonirspMetadataKey.roi_1_origin_x]
+        self.roi_1_origin_y = self.header[CryonirspMetadataKey.roi_1_origin_y]
+        self.roi_1_size_x = self.header[CryonirspMetadataKey.roi_1_size_x]
+        self.roi_1_size_y = self.header[CryonirspMetadataKey.roi_1_size_y]
 
 
 class CryonirspL0FitsAccess(L0FitsAccess):
@@ -71,46 +72,38 @@ class CryonirspL0FitsAccess(L0FitsAccess):
     ):
         super().__init__(hdu=hdu, name=name, auto_squeeze=auto_squeeze)
 
-        self.arm_id: str = self.header["CNARMID"]
-        self.number_of_modulator_states: int = self.header["CNMODNST"]
-        self.modulator_state: int = self.header["CNMODCST"]
-        self.scan_step: int = self.header["CNCURSCN"]
-        self.num_scan_steps: int = self.header["CNNUMSCN"]
-        self.num_cn1_scan_steps: int = self.header["CNP1DNSP"]
-        self.num_cn2_scan_steps: int = self.header["CNP2DNSP"]
-        self.cn2_step_size: float = self.header["CNP2DSS"]
-        self.meas_num: int = self.header["CNCMEAS"]
-        self.num_meas: int = self.header["CNNMEAS"]
-        self.sub_repeat_num = self.header["CNCSREP"]
-        self.num_sub_repeats: int = self.header["CNSUBREP"]
-        self.modulator_spin_mode: str = self.header["CNSPINMD"]
-        self.axis_1_type: str = self.header["CTYPE1"]
-        self.axis_2_type: str = self.header["CTYPE2"]
-        self.axis_3_type: str = self.header["CTYPE3"]
-        self.wave_min: float = round(
-            self.header["CRVAL1"] - (self.header["CRPIX1"] * self.header["CDELT1"]), 1
-        )
-        self.wave_max: float = round(
-            self.header["CRVAL1"]
-            + ((self.header["NAXIS1"] - self.header["CRPIX1"]) * self.header["CDELT1"]),
-            1,
-        )
-        self.grating_position_deg: float = self.header["CNGRTPOS"]
-        self.grating_littrow_angle_deg: float = self.header["CNGRTLAT"]
-        # grating_constant is in the L0 header in (mm)^(-1) when needed in (m)^(-1) hence multiply by 1000.
-        self.grating_constant: float = self.header["CNGRTCON"] * 1000
-        self.obs_ip_start_time = self.header["DKIST011"]
+        self.arm_id: str = self.header[CryonirspMetadataKey.arm_id]
+        self.number_of_modulator_states: int = self.header[
+            CryonirspMetadataKey.number_of_modulator_states
+        ]
+        self.modulator_state: int = self.header[CryonirspMetadataKey.modulator_state]
+        self.scan_step: int = self.header[CryonirspMetadataKey.scan_step]
+        self.num_scan_steps: int = self.header[CryonirspMetadataKey.num_scan_steps]
+        self.num_cn1_scan_steps: int = self.header[CryonirspMetadataKey.num_cn1_scan_steps]
+        self.num_cn2_scan_steps: int = self.header[CryonirspMetadataKey.num_cn2_scan_steps]
+        self.cn2_step_size: float = self.header[CryonirspMetadataKey.cn2_step_size]
+        self.meas_num: int = self.header[CryonirspMetadataKey.meas_num]
+        self.num_meas: int = self.header[CryonirspMetadataKey.num_meas]
+        self.sub_repeat_num = self.header[CryonirspMetadataKey.sub_repeat_num]
+        self.num_sub_repeats: int = self.header[CryonirspMetadataKey.num_sub_repeats]
+        self.modulator_spin_mode: str = self.header[CryonirspMetadataKey.modulator_spin_mode]
+        self.axis_1_type: str = self.header[CryonirspMetadataKey.axis_1_type]
+        self.axis_2_type: str = self.header[CryonirspMetadataKey.axis_2_type]
+        self.axis_3_type: str = self.header[CryonirspMetadataKey.axis_3_type]
+        self.grating_position_deg: float = self.header[CryonirspMetadataKey.grating_position_deg]
+        self.grating_littrow_angle_deg: float = self.header[
+            CryonirspMetadataKey.grating_littrow_angle_deg
+        ]
+        self.grating_constant: float = self.header[CryonirspMetadataKey.grating_constant]
+        self.filter_name = self.header[CryonirspMetadataKey.filter_name.value].upper()
         # The ExposureConditions are a combination of the exposure time and the OD filter name:
         self.exposure_conditions = ExposureConditions(
-            round(self.fpa_exposure_time_ms, CRYO_EXP_TIME_ROUND_DIGITS),
-            self.header["CNFILTNP"].upper(),
+            round(self.fpa_exposure_time_ms, CRYO_EXP_TIME_ROUND_DIGITS), self.filter_name
         )
-        self.solar_gain_ip_start_time = self.header["DATE-OBS"]
-
-    @property
-    def cn1_scan_step(self):
-        """Convert the inner loop step number from float to int."""
-        return int(self.header["CNP1DCUR"])
+        self.center_wavelength = self.header[CryonirspMetadataKey.center_wavelength]
+        self.slit_width = self.header[CryonirspMetadataKey.slit_width]
+        # Convert the inner loop step number from float to int:
+        self.cn1_scan_step = int(self.header[CryonirspMetadataKey.cn1_scan_step])
 
 
 class CryonirspLinearizedFitsAccess(CryonirspL0FitsAccess):

dkist_processing_cryonirsp/parsers/cryonirsp_l1_fits_access.py

@@ -1,4 +1,5 @@
 """CryoNIRSP FITS access for L1 data."""
+
 from astropy.io import fits
 from dkist_processing_common.parsers.l1_fits_access import L1FitsAccess
 

dkist_processing_cryonirsp/parsers/exposure_conditions.py

@@ -1,6 +1,7 @@
 """Buds to parse the combination of exposure time and filter name."""
-from collections import namedtuple
+
 from typing import Hashable
+from typing import NamedTuple
 from typing import Type
 
 from dkist_processing_common.models.flower_pot import SpilledDirt
@@ -28,7 +29,6 @@ class CryonirspTaskExposureConditionsBud(Stem):
 
     def __init__(self, stem_name: str, ip_task_type: str):
         super().__init__(stem_name=stem_name)
-        self.metadata_key = "exposure_conditions"
         self.ip_task_type = ip_task_type
 
     def setter(self, fits_obj: CryonirspL0FitsAccess):
@@ -42,7 +42,7 @@ class CryonirspTaskExposureConditionsBud(Stem):
         """
         ip_task_type = parse_header_ip_task_with_gains(fits_obj)
         if ip_task_type.lower() == self.ip_task_type.lower():
-            return getattr(fits_obj, self.metadata_key)
+            return fits_obj.exposure_conditions
         return SpilledDirt
 
     def getter(self, key: Hashable) -> tuple[ExposureConditions, ...]:
@@ -56,7 +56,6 @@ class CryonirspConditionalTaskExposureConditionsBudBase(Stem):
 
     def __init__(self, stem_name: str, task_types_to_ignore: list[str]):
         super().__init__(stem_name=stem_name)
-        self.metadata_key = "exposure_conditions"
         self.task_types_to_ignore = task_types_to_ignore
 
     def setter(self, fits_obj: CryonirspL0FitsAccess) -> ExposureConditions | Type[SpilledDirt]:
@@ -73,7 +72,7 @@ class CryonirspConditionalTaskExposureConditionsBudBase(Stem):
         """
         task_type = parse_header_ip_task_with_gains(fits_obj=fits_obj)
         if task_type.upper() not in self.task_types_to_ignore:
-            return getattr(fits_obj, self.metadata_key)
+            return fits_obj.exposure_conditions
         return SpilledDirt
 
     def getter(self, key: Hashable) -> tuple[ExposureConditions, ...]:
@@ -103,7 +102,6 @@ class CryonirspSPConditionalTaskExposureConditionsBud(
             stem_name=CryonirspBudName.sp_non_dark_and_non_polcal_task_exposure_conditions_list.value,
             task_types_to_ignore=[TaskName.dark.value, TaskName.polcal.value],
         )
-        self.metadata_key = "exposure_conditions"
 
 
 class CryonirspCIConditionalTaskExposureConditionsBud(
@@ -120,19 +118,22 @@ class CryonirspCIConditionalTaskExposureConditionsBud(
                 TaskName.lamp_gain.value,
             ],
         )
-        self.metadata_key = "exposure_conditions"
+
+
+class DarkTaskTestAndExposureConditionsContainer(NamedTuple):
+    """Named tuple to hold whether the task is dark along with the associated exposure conditions."""
+
+    is_dark: bool
+    exposure_conditions: ExposureConditions
 
 
 class CryonirspPickyDarkExposureConditionsBudBase(Stem):
     """Parse exposure conditions tuples to ensure existence of dark frames with the required exposure conditions."""
 
-    DarkTaskTestAndExposureConditions = namedtuple(
-        "DarkTaskTestAndExposureConditions", ["is_dark", "exposure_conditions"]
-    )
+    DarkTaskTestAndExposureConditions = DarkTaskTestAndExposureConditionsContainer
 
     def __init__(self, stem_name: str, task_types_to_ignore: list[str]):
         super().__init__(stem_name=stem_name)
-        self.metadata_key = "exposure_conditions"
         self.task_types_to_ignore = task_types_to_ignore
 
     def setter(self, fits_obj: CryonirspL0FitsAccess) -> tuple | Type[SpilledDirt]:
@@ -150,11 +151,11 @@ class CryonirspPickyDarkExposureConditionsBudBase(Stem):
         task_type = parse_header_ip_task_with_gains(fits_obj=fits_obj)
         if task_type.upper() == TaskName.dark.value:
             return self.DarkTaskTestAndExposureConditions(
-                is_dark=True, exposure_conditions=getattr(fits_obj, self.metadata_key)
+                is_dark=True, exposure_conditions=fits_obj.exposure_conditions
             )
         if task_type.upper() not in self.task_types_to_ignore:
             return self.DarkTaskTestAndExposureConditions(
-                is_dark=False, exposure_conditions=getattr(fits_obj, self.metadata_key)
+                is_dark=False, exposure_conditions=fits_obj.exposure_conditions
             )
             # Ignored task types fall through
         return SpilledDirt

dkist_processing_cryonirsp/parsers/map_repeats.py

@@ -1,4 +1,5 @@
 """Stems for organizing files into separate dsps repeats."""
+
 from dkist_processing_cryonirsp.models.constants import CryonirspBudName
 from dkist_processing_cryonirsp.models.tags import CryonirspStemName
 from dkist_processing_cryonirsp.parsers.scan_step import MapScanStepStemBase

dkist_processing_cryonirsp/parsers/measurements.py

@@ -1,45 +1,58 @@
 """Copies of UniqueBud and SingleValueSingleKeyFlower from common that only activate if the frames are "observe" task."""
+
+from typing import Hashable
 from typing import Type
 
 from dkist_processing_common.models.flower_pot import SpilledDirt
 from dkist_processing_common.parsers.single_value_single_key_flower import (
     SingleValueSingleKeyFlower,
 )
-from dkist_processing_common.parsers.unique_bud import UniqueBud
 
 from dkist_processing_cryonirsp.models.constants import CryonirspBudName
+from dkist_processing_cryonirsp.models.fits_access import CryonirspMetadataKey
 from dkist_processing_cryonirsp.models.tags import CryonirspStemName
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
+from dkist_processing_cryonirsp.parsers.scan_step import NumberOfScanStepsBase
 
 
-class NumberOfMeasurementsBud(UniqueBud):
+class NumberOfMeasurementsBud(NumberOfScanStepsBase):
     """Bud for finding the total number of measurements per scan step."""
 
     def __init__(self):
-        self.metadata_key = "num_meas"
-        super().__init__(
-            constant_name=CryonirspBudName.num_meas.value, metadata_key=self.metadata_key
-        )
+        super().__init__(stem_name=CryonirspBudName.num_meas.value)
 
-    def setter(self, fits_obj: CryonirspL0FitsAccess) -> Type[SpilledDirt] | int:
+    def getter(self, key: Hashable) -> Hashable:
         """
-        Setter for the bud.
+        Search all scan steps to find the maximum number of measurements in a step.
 
-        Parameters
-        ----------
-        fits_obj:
-            A single FitsAccess object
+        This maximum number should be the same for all measurements, with the possible exception of the last one in
+        an abort.
+
+        Abort possibilities:
+        * if a measurement is missing in the last scan step of a multi-scan, multi-map observation, it will be handled
+        as an incomplete scan step and truncated by the scan step abort handler.
+        * if a measurement is missing in a single-map, single-scan observation then the number of measurements will be
+        given by the last measurement value that had as many frames as the maximum number of frames of any
+        measurement.
+        This is a formality for intensity mode observations but is an important check for polarimetric data as the
+        abort may have happened in the middle of the modulator state sequence.
         """
-        if fits_obj.ip_task_type != "observe":
-            return SpilledDirt
-        return getattr(fits_obj, self.metadata_key)
+        measurements_in_scan_steps = []
+        for meas_dict in self.scan_step_dict.values():
+            measurements_in_scan_steps.append(len(meas_dict))
+        return max(
+            measurements_in_scan_steps
+        )  # if there are incomplete measurements, they should be at the end and will be truncated by an incomplete scan step
 
 
 class MeasurementNumberFlower(SingleValueSingleKeyFlower):
     """Flower for a measurement number."""
 
     def __init__(self):
-        super().__init__(tag_stem_name=CryonirspStemName.meas_num.value, metadata_key="meas_num")
+        super().__init__(
+            tag_stem_name=CryonirspStemName.meas_num.value,
+            metadata_key=CryonirspMetadataKey.meas_num,
+        )
 
     def setter(self, fits_obj: CryonirspL0FitsAccess) -> Type[SpilledDirt] | int:
         """

dkist_processing_cryonirsp/parsers/modstates.py

@@ -1,4 +1,5 @@
 """Copy of SingleValueSingleKeyFlower from common that only activates if the frames are "observe" task."""
+
 from typing import Type
 
 from dkist_processing_common.models.flower_pot import SpilledDirt
@@ -7,6 +8,7 @@ from dkist_processing_common.parsers.single_value_single_key_flower import (
     SingleValueSingleKeyFlower,
 )
 
+from dkist_processing_cryonirsp.models.fits_access import CryonirspMetadataKey
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
 
 
@@ -14,7 +16,9 @@ class ModstateNumberFlower(SingleValueSingleKeyFlower):
     """Flower for a modstate number."""
 
     def __init__(self):
-        super().__init__(tag_stem_name=StemName.modstate.value, metadata_key="modulator_state")
+        super().__init__(
+            tag_stem_name=StemName.modstate.value, metadata_key=CryonirspMetadataKey.modulator_state
+        )
 
     def setter(self, fits_obj: CryonirspL0FitsAccess) -> Type[SpilledDirt] | int:
         """

dkist_processing_cryonirsp/parsers/optical_density_filters.py

@@ -1,4 +1,5 @@
 """PickyBud to implement early parsing of Optical Density Filter Names."""
+
 from typing import Hashable
 
 from dkist_processing_common.models.flower_pot import Stem