dkist-processing-common 10.5.4__py3-none-any.whl → 12.1.0rc1__py3-none-any.whl

dkist_processing_common/parsers/experiment_id_bud.py

@@ -1,14 +1,21 @@
 """Experiment Id parser."""
+
 from dkist_processing_common.models.constants import BudName
+from dkist_processing_common.models.fits_access import MetadataKey
+from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.parsers.id_bud import ContributingIdsBud
-from dkist_processing_common.parsers.id_bud import IdBud
+from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
 
 
-class ExperimentIdBud(IdBud):
+class ExperimentIdBud(TaskUniqueBud):
     """Class to create a Bud for the experiment_id."""
 
     def __init__(self):
-        super().__init__(constant_name=BudName.experiment_id.value, metadata_key="experiment_id")
+        super().__init__(
+            constant_name=BudName.experiment_id,
+            metadata_key=MetadataKey.experiment_id,
+            ip_task_types=TaskName.observe,
+        )
 
 
 class ContributingExperimentIdsBud(ContributingIdsBud):
@@ -16,5 +23,6 @@ class ContributingExperimentIdsBud(ContributingIdsBud):
 
     def __init__(self):
         super().__init__(
-            stem_name=BudName.contributing_experiment_ids.value, metadata_key="experiment_id"
+            constant_name=BudName.contributing_experiment_ids,
+            metadata_key=MetadataKey.experiment_id,
         )

dkist_processing_common/parsers/id_bud.py

@@ -1,32 +1,25 @@
 """Base classes for ID bud parsing."""
+
+from enum import StrEnum
+from typing import Callable
 from typing import Type
 
+from dkist_processing_common.models.flower_pot import SetStem
 from dkist_processing_common.models.flower_pot import SpilledDirt
-from dkist_processing_common.models.flower_pot import Stem
-from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
-from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
-
-
-class IdBud(TaskUniqueBud):
-    """Base class for ID buds."""
-
-    def __init__(self, constant_name, metadata_key):
-        super().__init__(
-            constant_name=constant_name,
-            metadata_key=metadata_key,
-            ip_task_type=TaskName.observe.value,
-        )
+from dkist_processing_common.parsers.task import passthrough_header_ip_task
 
 
-class ContributingIdsBud(Stem):
+class ContributingIdsBud(SetStem):
     """Base class for contributing ID buds."""
 
-    def __init__(self, stem_name, metadata_key):
-        super().__init__(stem_name=stem_name)
+    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
 
-    def setter(self, fits_obj: L0FitsAccess) -> str | Type[SpilledDirt]:
+    def setter(self, fits_obj: L0FitsAccess) -> str:
         """
         Set the id for any type of frame.
 
@@ -40,17 +33,39 @@ class ContributingIdsBud(Stem):
         """
         return getattr(fits_obj, self.metadata_key)
 
-    def getter(self, key) -> tuple:
+    def getter(self) -> tuple[str, ...]:
         """
-        Get all ids seen in non observe frames.
-
-        Parameters
-        ----------
-        key
-            The input key
+        Get all ids seen for any type of frame.
 
         Returns
         -------
-        IDs from non observe frames
+        IDs from all types of frames
         """
-        return tuple(set(self.key_to_petal_dict.values()))
+        return tuple(self.value_set)
+
+
+class TaskContributingIdsBud(ContributingIdsBud):
+    """Base class for contributing ID buds for a particular task type."""
+
+    def __init__(
+        self,
+        constant_name: str,
+        metadata_key: str | StrEnum,
+        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)
+
+        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) -> str | Type[SpilledDirt]:
+        """Ingest an object only if its parsed IP task type matches what's desired."""
+        task = self.parsing_function(fits_obj)
+
+        if task.casefold() in self.ip_task_types:
+            return super().setter(fits_obj)
+
+        return SpilledDirt

dkist_processing_common/parsers/l0_fits_access.py

@@ -1,6 +1,8 @@
 """By-frame 214 L0 header keywords that are not instrument specific."""
+
 from astropy.io import fits
 
+from dkist_processing_common.models.fits_access import MetadataKey
 from dkist_processing_common.parsers.l1_fits_access import L1FitsAccess
 
 
@@ -25,6 +27,6 @@ class L0FitsAccess(L1FitsAccess):
         auto_squeeze: bool = True,
     ):
         super().__init__(hdu=hdu, name=name, auto_squeeze=auto_squeeze)
-        self.ip_task_type: str = self.header["IPTASK"]
-        self.ip_start_time: str = self.header["DKIST011"]
-        self.ip_end_time: str = self.header["DKIST012"]
+        self.ip_task_type: str = self.header[MetadataKey.ip_task_type]
+        self.ip_start_time: str = self.header[MetadataKey.ip_start_time]
+        self.ip_end_time: str = self.header[MetadataKey.ip_end_time]

dkist_processing_common/parsers/l1_fits_access.py

@@ -1,7 +1,12 @@
 """By-frame 214 L1 only header keywords that are not instrument specific."""
+
 from astropy.io import fits
 
+from dkist_processing_common.models.fits_access import HEADER_KEY_NOT_FOUND
 from dkist_processing_common.models.fits_access import FitsAccessBase
+from dkist_processing_common.models.fits_access import MetadataKey
+
+NOT_A_FLOAT = -999
 
 
 class L1FitsAccess(FitsAccessBase):
@@ -26,38 +31,61 @@ class L1FitsAccess(FitsAccessBase):
     ):
         super().__init__(hdu=hdu, name=name, auto_squeeze=auto_squeeze)
 
-        self.elevation: float = self.header["ELEV_ANG"]
-        self.azimuth: float = self.header["TAZIMUTH"]
-        self.table_angle: float = self.header["TTBLANGL"]
-        self.gos_level3_status: str = self.header["LVL3STAT"]
-        self.gos_level3_lamp_status: str = self.header["LAMPSTAT"]
-        self.gos_polarizer_status: str = self.header["LVL2STAT"]
-        self.gos_retarder_status: str = self.header["LVL1STAT"]
-        self.gos_level0_status: str = self.header["LVL0STAT"]
-        self.time_obs: str = self.header["DATE-BEG"]
-        self.ip_id: str = self.header["IP_ID"]
-        self.instrument: str = self.header["INSTRUME"]
-        self.wavelength: float = self.header["LINEWAV"]
-        self.proposal_id: str = self.header["PROP_ID"]
-        self.experiment_id: str = self.header["EXPER_ID"]
-        self.num_dsps_repeats: int = self.header["DSPSREPS"]
-        self.current_dsps_repeat: int = self.header["DSPSNUM"]
-        self.fpa_exposure_time_ms: float = self.header["XPOSURE"]
-        self.sensor_readout_exposure_time_ms: float = self.header["TEXPOSUR"]
-        self.num_raw_frames_per_fpa: int = self.header["NSUMEXP"]
+        self.elevation: float = self.header[MetadataKey.elevation]
+        self.azimuth: float = self.header[MetadataKey.azimuth]
+        self.table_angle: float = self.header[MetadataKey.table_angle]
+        self.gos_level3_status: str = self.header[MetadataKey.gos_level3_status]
+        self.gos_level3_lamp_status: str = self.header[MetadataKey.gos_level3_lamp_status]
+        self.gos_polarizer_status: str = self.header[MetadataKey.gos_polarizer_status]
+        self.gos_retarder_status: str = self.header[MetadataKey.gos_retarder_status]
+        self.gos_level0_status: str = self.header[MetadataKey.gos_level0_status]
+        self.time_obs: str = self.header[MetadataKey.time_obs]
+        self.ip_id: str = self.header[MetadataKey.ip_id]
+        self.instrument: str = self.header[MetadataKey.instrument]
+        self.wavelength: float = self.header[MetadataKey.wavelength]
+        self.proposal_id: str = self.header[MetadataKey.proposal_id]
+        self.experiment_id: str = self.header[MetadataKey.experiment_id]
+        self.num_dsps_repeats: int = self.header[MetadataKey.num_dsps_repeats]
+        self.current_dsps_repeat: int = self.header[MetadataKey.current_dsps_repeat]
+        self.fpa_exposure_time_ms: float = self.header[MetadataKey.fpa_exposure_time_ms]
+        self.sensor_readout_exposure_time_ms: float = self.header[
+            MetadataKey.sensor_readout_exposure_time_ms
+        ]
+        self.num_raw_frames_per_fpa: int = self.header[MetadataKey.num_raw_frames_per_fpa]
+        self.camera_id: str = self.header[MetadataKey.camera_id]
+        self.camera_name: str = self.header[MetadataKey.camera_name]
+        self.camera_bit_depth: int = self.header[MetadataKey.camera_bit_depth]
+        self.hardware_binning_x: int = self.header[MetadataKey.hardware_binning_x]
+        self.hardware_binning_y: int = self.header[MetadataKey.hardware_binning_y]
+        self.software_binning_x: int = self.header[MetadataKey.software_binning_x]
+        self.software_binning_y: int = self.header[MetadataKey.software_binning_y]
+        self.observing_program_execution_id: str = self.header[
+            MetadataKey.observing_program_execution_id
+        ]
+        self.telescope_tracking_mode: str = self.header.get(
+            MetadataKey.telescope_tracking_mode, HEADER_KEY_NOT_FOUND
+        )
+        self.coude_table_tracking_mode: str = self.header.get(
+            MetadataKey.coude_table_tracking_mode, HEADER_KEY_NOT_FOUND
+        )
+        self.telescope_scanning_mode: str = self.header.get(
+            MetadataKey.telescope_scanning_mode, HEADER_KEY_NOT_FOUND
+        )
+        self.light_level: float = self.header[MetadataKey.light_level]
+        self.hls_version: str = self.header[MetadataKey.hls_version]
 
     @property
     def gos_polarizer_angle(self) -> float:
         """Convert the polarizer angle to a float if possible before returning."""
         try:
-            return float(self.header["POLANGLE"])
+            return float(self.header[MetadataKey.gos_polarizer_angle])
         except ValueError:
-            return -999  # The angle is only used if the polarizer is in the beam
+            return NOT_A_FLOAT  # The angle is only used if the polarizer is in the beam
 
     @property
     def gos_retarder_angle(self) -> float:
         """Convert the retarder angle to a float if possible before returning."""
         try:
-            return float(self.header["RETANGLE"])
+            return float(self.header[MetadataKey.gos_retarder_angle])
         except ValueError:
-            return -999  # The angle is only used if the retarder is in the beam
+            return NOT_A_FLOAT  # The angle is only used if the retarder is in the beam

dkist_processing_common/parsers/lookup_bud.py

@@ -0,0 +1,125 @@
+"""Simple bud that is used to set a constant to a mapping dictionary."""
+
+from collections import defaultdict
+from enum import StrEnum
+from typing import Any
+from typing import Callable
+from typing import DefaultDict
+
+from dkist_processing_common.models.flower_pot import SetStem
+from dkist_processing_common.models.flower_pot import SpilledDirt
+from dkist_processing_common.models.tags import EXP_TIME_ROUND_DIGITS
+from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
+from dkist_processing_common.parsers.task import passthrough_header_ip_task
+
+
+class TimeLookupBud(SetStem):
+    """
+    Bud that reads two header keys from all files and creates a dictionary mapping a time KEY value to sets of a VALUE value.
+
+    Parameters
+    ----------
+    constant_name
+        The name for the constant to be defined
+
+    key_metadata_key
+        The time metadata key for the resulting dictionary key
+
+    value_metadata_key
+        The metadata key for the resulting dictionary value
+    """
+
+    def __init__(
+        self,
+        constant_name: str,
+        key_metadata_key: str | StrEnum,
+        value_metadata_key: str | StrEnum,
+    ):
+        super().__init__(stem_name=constant_name)
+
+        if isinstance(key_metadata_key, StrEnum):
+            key_metadata_key = key_metadata_key.name
+        self.key_metadata_key = key_metadata_key
+        if isinstance(value_metadata_key, StrEnum):
+            value_metadata_key = value_metadata_key.name
+        self.value_metadata_key = value_metadata_key
+
+        self.mapping: DefaultDict[float, set[Any]] = defaultdict(set)
+
+    def setter(self, fits_obj: L0FitsAccess):
+        """
+        Update the mapping dictionary.
+
+        Parameters
+        ----------
+        fits_obj
+            The input fits object
+        Returns
+        -------
+        Updates the dictionary and returns None
+        """
+        key = getattr(fits_obj, self.key_metadata_key)
+        rounded_key = round(key, EXP_TIME_ROUND_DIGITS)
+        value = getattr(fits_obj, self.value_metadata_key)
+        self.mapping[rounded_key].add(value)
+        return None
+
+    def getter(self):
+        """
+        Get the dictionary mapping created by the setter with values converted to JSON-able lists.
+
+        Returns
+        -------
+        The mapping dictionary with values converted to JSON-able lists
+        """
+        mapping_lists = {k: list(v) for k, v in self.mapping.items()}
+        return mapping_lists
+
+
+class TaskTimeLookupBud(TimeLookupBud):
+    """
+    Subclass of `TimeLookupBud` that only considers objects that have specific task types.
+
+    Parameters
+    ----------
+    constant_name
+        The name for the constant to be defined
+
+    key_metadata_key
+        The time metadata key for the resulting dictionary key
+
+    value_metadata_key
+        The metadata key for the resulting dictionary value
+
+    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
+    """
+
+    def __init__(
+        self,
+        constant_name: str,
+        key_metadata_key: str | StrEnum,
+        value_metadata_key: str | StrEnum,
+        ip_task_types: str | list[str],
+        task_type_parsing_function: Callable = passthrough_header_ip_task,
+    ):
+        super().__init__(
+            constant_name=constant_name,
+            key_metadata_key=key_metadata_key,
+            value_metadata_key=value_metadata_key,
+        )
+        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() in self.ip_task_types:
+            return super().setter(fits_obj)
+
+        return SpilledDirt

dkist_processing_common/parsers/near_bud.py

@@ -1,16 +1,18 @@
 """Pre-made flower that reads a single header key from all files and raises a ValueError if the values are not in a supplied range."""
+
+from enum import StrEnum
 from statistics import mean
 from typing import Callable
 
+from dkist_processing_common.models.flower_pot import ListStem
 from dkist_processing_common.models.flower_pot import SpilledDirt
-from dkist_processing_common.models.flower_pot import Stem
 from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
 from dkist_processing_common.parsers.task import passthrough_header_ip_task
 
 
-class NearFloatBud(Stem):
+class NearFloatBud(ListStem):
     """
-    Pre-made flower that reads a single header key from all files and raises a ValueError if the values are not within a given tolerance.
+    Pre-made `ListStem` that reads a single header key from all files and raises a ValueError if the values are not within a given tolerance.
 
     This is intended for use with floats where the values may be slightly different, but should be the same.
 
@@ -29,10 +31,12 @@ class NearFloatBud(Stem):
     def __init__(
         self,
         constant_name: str,
-        metadata_key: str,
+        metadata_key: str | StrEnum,
         tolerance: float,
     ):
         super().__init__(stem_name=constant_name)
+        if isinstance(metadata_key, StrEnum):
+            metadata_key = metadata_key.name
         self.metadata_key = metadata_key
         self.tolerance = tolerance
 
@@ -50,31 +54,26 @@ class NearFloatBud(Stem):
         """
         return getattr(fits_obj, self.metadata_key)
 
-    def getter(self, key):
+    def getter(self):
         """
         Get the value for this key and raise an error if the data spans more than the given tolerance.
 
-        Parameters
-        ----------
-        key
-            The input key
         Returns
         -------
         The mean value associated with this input key
         """
-        value_set = list(self.key_to_petal_dict.values())
-        biggest_value = max(value_set)
-        smallest_value = min(value_set)
+        biggest_value = max(self.value_list)
+        smallest_value = min(self.value_list)
         if biggest_value - smallest_value > self.tolerance:
             raise ValueError(
                 f"{self.stem_name} values are not close enough. Max: {biggest_value}, Min: {smallest_value}, Tolerance: {self.tolerance}"
             )
-        return mean(value_set)
+        return mean(self.value_list)
 
 
 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 +83,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
@@ -97,8 +96,8 @@ class TaskNearFloatBud(NearFloatBud):
     def __init__(
         self,
         constant_name: str,
-        metadata_key: str,
-        ip_task_type: str,
+        metadata_key: str | StrEnum,
+        ip_task_types: str | list[str],
         tolerance: float,
         task_type_parsing_function: Callable = passthrough_header_ip_task,
     ):
@@ -106,14 +105,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/parsers/observing_program_id_bud.py

@@ -0,0 +1,24 @@
+"""Observing Program Id parser."""
+
+from typing import Callable
+
+from dkist_processing_common.models.fits_access import MetadataKey
+from dkist_processing_common.parsers.id_bud import TaskContributingIdsBud
+from dkist_processing_common.parsers.task import passthrough_header_ip_task
+
+
+class TaskContributingObservingProgramExecutionIdsBud(TaskContributingIdsBud):
+    """Class to create a Bud for the supporting observing_program_execution_ids."""
+
+    def __init__(
+        self,
+        constant_name: str,
+        ip_task_types: str | list[str],
+        task_type_parsing_function: Callable = passthrough_header_ip_task,
+    ):
+        super().__init__(
+            constant_name=constant_name,
+            metadata_key=MetadataKey.observing_program_execution_id,
+            ip_task_types=ip_task_types,
+            task_type_parsing_function=task_type_parsing_function,
+        )

dkist_processing_common/parsers/proposal_id_bud.py

@@ -1,20 +1,28 @@
 """Proposal Id parser."""
+
 from dkist_processing_common.models.constants import BudName
+from dkist_processing_common.models.fits_access import MetadataKey
+from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.parsers.id_bud import ContributingIdsBud
-from dkist_processing_common.parsers.id_bud import IdBud
+from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
 
 
-class ProposalIdBud(IdBud):
+class ProposalIdBud(TaskUniqueBud):
     """Class to create a Bud for the proposal_id."""
 
     def __init__(self):
-        super().__init__(constant_name=BudName.proposal_id.value, metadata_key="proposal_id")
+        super().__init__(
+            constant_name=BudName.proposal_id,
+            metadata_key=MetadataKey.proposal_id,
+            ip_task_types=TaskName.observe,
+        )
 
 
 class ContributingProposalIdsBud(ContributingIdsBud):
-    """Class to create a Bud for the proposal_ids."""
+    """Class to create a Bud for the supporting proposal_ids."""
 
     def __init__(self):
         super().__init__(
-            stem_name=BudName.contributing_proposal_ids.value, metadata_key="proposal_id"
+            constant_name=BudName.contributing_proposal_ids,
+            metadata_key=MetadataKey.proposal_id,
         )

dkist_processing_common/parsers/quality.py

@@ -1,4 +1,5 @@
 """Support classes to define object attributes from header information."""
+
 from astropy.io import fits
 
 from dkist_processing_common.parsers.l0_fits_access import L1FitsAccess
@@ -31,3 +32,4 @@ class L1QualityFitsAccess(L1FitsAccess):
         self.light_level: float = self.header["LIGHTLVL"]
         self.health_status: str = self.header["DSHEALTH"]
         self.ao_status: int = self.header.get("AO_LOCK", None)
+        self.num_out_of_bounds_ao_values: int = self.header.get("OOBSHIFT", None)

dkist_processing_common/parsers/retarder.py

@@ -0,0 +1,32 @@
+"""Bud that parses the name of the retarder used during POLCAL task observations."""
+
+from dkist_processing_common.models.constants import BudName
+from dkist_processing_common.models.fits_access import MetadataKey
+from dkist_processing_common.models.flower_pot import SpilledDirt
+from dkist_processing_common.models.task_name import TaskName
+from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
+from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
+
+
+class RetarderNameBud(TaskUniqueBud):
+    """
+    Bud for determining the name of the retarder used during a polcal Calibration Sequence (CS).
+
+    This is *slightly* different than a simple `TaskUniqueBud` because we need to allow for CS steps when the retarder
+    is out of the beam (i.g., "clear"). We do this by returning `SpilledDirt` from the `setter` if the value is "clear".
+    """
+
+    def __init__(self):
+        super().__init__(
+            constant_name=BudName.retarder_name,
+            metadata_key=MetadataKey.gos_retarder_status,
+            ip_task_types=TaskName.polcal,
+        )
+
+    def setter(self, fits_obj: L0FitsAccess) -> type[SpilledDirt] | str:
+        """Drop the result if the retarder is out of the beam ("clear")."""
+        result = super().setter(fits_obj)
+        if result is not SpilledDirt and result.casefold() == "clear":
+            return SpilledDirt
+
+        return result

dkist_processing_common/parsers/single_value_single_key_flower.py

@@ -1,4 +1,7 @@
 """Pre-made flower that produces tag based on a single header key."""
+
+from enum import StrEnum
+
 from dkist_processing_common.models.flower_pot import Stem
 from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
 
@@ -15,8 +18,10 @@ class SingleValueSingleKeyFlower(Stem):
         The metadata key
     """
 
-    def __init__(self, tag_stem_name: str, metadata_key: str):
+    def __init__(self, tag_stem_name: str, metadata_key: str | StrEnum):
         super().__init__(stem_name=tag_stem_name)
+        if isinstance(metadata_key, StrEnum):
+            metadata_key = metadata_key.name
         self.metadata_key = metadata_key
 
     def setter(self, fits_obj: L0FitsAccess):

dkist_processing_common/parsers/task.py

@@ -1,8 +1,10 @@
 """Module for parsing IP task related things."""
+
 from typing import Callable
 from typing import Type
 
 from dkist_processing_common.models.fits_access import FitsAccessBase
+from dkist_processing_common.models.fits_access import MetadataKey
 from dkist_processing_common.models.flower_pot import SpilledDirt
 from dkist_processing_common.models.tags import StemName
 from dkist_processing_common.models.task_name import TaskName
@@ -35,9 +37,9 @@ def parse_header_ip_task_with_gains(fits_obj: FitsAccessBase) -> str:
         and fits_obj.gos_level3_status == "lamp"
         and fits_obj.gos_level3_lamp_status == "on"
     ):
-        return TaskName.lamp_gain.value
+        return TaskName.lamp_gain
     if fits_obj.ip_task_type == "gain" and fits_obj.gos_level3_status == "clear":
-        return TaskName.solar_gain.value
+        return TaskName.solar_gain
 
     # Everything else is unchanged
     return passthrough_header_ip_task(fits_obj)
@@ -58,14 +60,14 @@ def parse_polcal_task_type(fits_obj: Type[FitsAccessBase]) -> str | Type[Spilled
         and fits_obj.gos_retarder_status == "clear"
         and fits_obj.gos_polarizer_status == "clear"
     ):
-        return TaskName.polcal_dark.value
+        return TaskName.polcal_dark
 
     elif (
         fits_obj.gos_level0_status.startswith("FieldStop")
         and fits_obj.gos_retarder_status == "clear"
         and fits_obj.gos_polarizer_status == "clear"
     ):
-        return TaskName.polcal_gain.value
+        return TaskName.polcal_gain
 
     # We don't care about a POLCAL frame that is neither dark nor clear
     return SpilledDirt
@@ -77,7 +79,7 @@ class TaskTypeFlower(SingleValueSingleKeyFlower):
     def __init__(
         self, header_task_parsing_func: Callable[[FitsAccessBase], str] = passthrough_header_ip_task
     ):
-        super().__init__(tag_stem_name=StemName.task.value, metadata_key="ip_task_type")
+        super().__init__(tag_stem_name=StemName.task, metadata_key=MetadataKey.ip_task_type)
         self.header_parsing_function = header_task_parsing_func
 
     def setter(self, fits_obj: FitsAccessBase):
@@ -102,7 +104,7 @@ class PolcalTaskFlower(SingleValueSingleKeyFlower):
     """
 
     def __init__(self):
-        super().__init__(tag_stem_name=StemName.task.value, metadata_key="ip_task_type")
+        super().__init__(tag_stem_name=StemName.task, metadata_key=MetadataKey.ip_task_type)
 
     def setter(self, fits_obj: FitsAccessBase):
         """