dkist-processing-cryonirsp 1.10.0rc1__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,4 +1,5 @@
 """Configuration for the dkist-processing-cryonirsp package and the logging thereof."""
+
 from dkist_processing_common.config import DKISTProcessingCommonConfiguration
 from pydantic import Field
 

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,16 +1,16 @@
 """CryoNIRSP additions to common constants."""
-from enum import Enum
+
+from enum import StrEnum
 from enum import unique
 
 import astropy.units as u
-from dkist_processing_common.models.constants import BudName
 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"
@@ -19,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"
@@ -51,7 +49,7 @@ 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"
@@ -91,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:
@@ -227,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."""
@@ -252,7 +230,7 @@ class CryonirspConstants(ConstantsBase):
     @property
     def pac_init_set(self):
         """Return the label for the initial set of parameter values used when fitting demodulation matrices."""
-        retarder_name = self._db_dict[BudName.retarder_name.value]
+        retarder_name = self.retarder_name
         match retarder_name:
             case "SiO2 OC":
                 return "OCCal_VIS"

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
 

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,47 +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"]
-        self.grating_constant: float = self.header["CNGRTCON"]
-        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"]
-        self.center_wavelength = self.header["CNCENWAV"]
-        self.slit_width = self.header["CNSLITW"]
-
-    @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

dkist_processing_cryonirsp/parsers/polarimetric_check.py

@@ -1,5 +1,7 @@
 """Copy of UniqueBud from common that only activates if the frames are polarimetric "observe" or "polcal" task, or non-polarimetric "observe" task."""
-from collections import namedtuple
+
+from enum import StrEnum
+from typing import NamedTuple
 from typing import Type
 
 from dkist_processing_common.models.flower_pot import SpilledDirt
@@ -7,21 +9,30 @@ from dkist_processing_common.models.flower_pot import Stem
 from dkist_processing_common.models.flower_pot import Thorn
 from dkist_processing_common.models.task_name import TaskName
 
-from dkist_processing_cryonirsp.models.constants import CryonirspBudName
+from dkist_processing_cryonirsp.models.fits_access import CryonirspMetadataKey
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
 
 
+class PolarimetricValueDataContainer(NamedTuple):
+    """Named tuple to hold polarimetric metadata about a task."""
+
+    task: str
+    num_modstates: int
+    spin_mode: str
+    bud_value: str | int | float | bool
+
+
 class PolarimetricCheckingUniqueBud(Stem):
     """Bud for checking if frames are polarimetric."""
 
-    PolarimetricValueData = namedtuple(
-        "PolarimetricValueData", ["task", "num_modstates", "spin_mode", "bud_value"]
-    )
+    PolarimetricValueData = PolarimetricValueDataContainer
     observe_task_name = TaskName.observe.value.casefold()
     polcal_task_name = TaskName.polcal.value.casefold()
 
-    def __init__(self, constant_name: str, metadata_key: str):
+    def __init__(self, constant_name: str, metadata_key: str | StrEnum):
         super().__init__(stem_name=constant_name)
+        if isinstance(metadata_key, StrEnum):
+            metadata_key = metadata_key.name
         self.metadata_key = metadata_key
 
     @property
@@ -71,7 +82,7 @@ class PolarimetricCheckingUniqueBud(Stem):
         # Some intensity mode data has the number of modulator states set to 0
         num_modstates = fits_obj.number_of_modulator_states or 1
 
-        if self.metadata_key == "number_of_modulator_states":
+        if self.metadata_key == CryonirspMetadataKey.number_of_modulator_states.name:
             bud_value = num_modstates
         else:
             bud_value = getattr(fits_obj, self.metadata_key)

dkist_processing_cryonirsp/parsers/scan_step.py

@@ -3,6 +3,7 @@ Machinery for sorting files based on scan step.
 
 Also includes base classes that can be used to sort files based on map scan.
 """
+
 ######################
 # HOW THIS ALL WORKS #
 ######################
@@ -312,11 +313,11 @@ class MapScanStepStemBase(Stem, ABC):
         return step_list.index(scan_step_obj) + 1  # Here we decide that map scan indices start at 1
 
 
-class NumberOfScanStepsBud(MapScanStepStemBase):
-    """Bud for finding the total number of scan steps."""
+class NumberOfScanStepsBase(MapScanStepStemBase, ABC):
+    """Base class for managing scan steps."""
 
-    def __init__(self):
-        super().__init__(stem_name=CryonirspBudName.num_scan_steps.value)
+    def __init__(self, stem_name: CryonirspBudName):
+        super().__init__(stem_name=stem_name)
 
     @cached_property
     def map_scan_to_obj_dict(self) -> dict[int, list[SingleScanStep]]:
@@ -361,6 +362,13 @@ class NumberOfScanStepsBud(MapScanStepStemBase):
 
         return len(completed_steps)
 
+
+class NumberOfScanStepsBud(NumberOfScanStepsBase):
+    """Bud for finding the total number of scan steps."""
+
+    def __init__(self):
+        super().__init__(stem_name=CryonirspBudName.num_scan_steps.value)
+
     def getter(self, key):
         """
         Compute the number of complete scan steps.