dkist-processing-common 11.7.0rc2__py3-none-any.whl → 11.7.1rc1__py3-none-any.whl

changelog/271.misc.rst

@@ -0,0 +1 @@
+Move `solar-wavelength-calibration` dep to 2.0.0 and make use of new helper properties in that release.

dkist_processing_common/models/constants.py

@@ -6,7 +6,6 @@ accessing the database (tab completion, etc.)
 """
 
 from enum import StrEnum
-from enum import unique
 from string import ascii_uppercase
 
 from sqids import Sqids
@@ -14,7 +13,6 @@ from sqids import Sqids
 from dkist_processing_common._util.constants import ConstantsDb
 
 
-@unique
 class BudName(StrEnum):
     """Controlled list of names for constant stems (buds)."""
 
@@ -35,62 +33,6 @@ class BudName(StrEnum):
     dark_exposure_times = "DARK_EXPOSURE_TIMES"
     dark_readout_exp_times = "DARK_READOUT_EXP_TIMES"
     wavelength = "WAVELENGTH"
-    camera_id = "CAMERA_ID"
-    camera_name = "CAMERA_NAME"
-    camera_bit_depth = "CAMERA_BIT_DEPTH"
-    hardware_binning_x = "HARDWARE_BINNING_X"
-    hardware_binning_y = "HARDWARE_BINNING_Y"
-    software_binning_x = "SOFTWARE_BINNING_X"
-    software_binning_y = "SOFTWARE_BINNING_Y"
-    hls_version = "HLS_VERSION"
-    # Multi-task buds start here:
-    dark_observing_program_execution_id = "DARK_OBSERVING_PROGRAM_EXECUTION_ID"
-    solar_gain_observing_program_execution_id = "SOLAR_GAIN_OBSERVING_PROGRAM_EXECUTION_ID"
-    polcal_observing_program_execution_id = "POLCAL_OBSERVING_PROGRAM_EXECUTION_ID"
-    dark_date_begin = "DARK_DATE_BEGIN"
-    solar_gain_date_begin = "SOLAR_GAIN_DATE_BEGIN"
-    polcal_date_begin = "POLCAL_DATE_BEGIN"
-    dark_date_end = "DARK_DATE_END"
-    solar_gain_date_end = "SOLAR_GAIN_DATE_END"
-    polcal_date_end = "POLCAL_DATE_END"
-    dark_num_raw_frames_per_fpa = "DARK_NUM_RAW_FRAMES_PER_FPA"
-    solar_gain_num_raw_frames_per_fpa = "SOLAR_GAIN_NUM_RAW_FRAMES_PER_FPA"
-    polcal_num_raw_frames_per_fpa = "POLCAL_NUM_RAW_FRAMES_PER_FPA"
-    dark_telescope_tracking_mode = "DARK_TELESCOPE_TRACKING_MODE"
-    solar_gain_telescope_tracking_mode = "SOLAR_GAIN_TELESCOPE_TRACKING_MODE"
-    polcal_telescope_tracking_mode = "POLCAL_TELESCOPE_TRACKING_MODE"
-    dark_coude_table_tracking_mode = "DARK_COUDE_TABLE_TRACKING_MODE"
-    solar_gain_coude_table_tracking_mode = "SOLAR_GAIN_COUDE_TABLE_TRACKING_MODE"
-    polcal_coude_table_tracking_mode = "POLCAL_COUDE_TABLE_TRACKING_MODE"
-    dark_telescope_scanning_mode = "DARK_TELESCOPE_SCANNING_MODE"
-    solar_gain_telescope_scanning_mode = "SOLAR_GAIN_TELESCOPE_SCANNING_MODE"
-    polcal_telescope_scanning_mode = "POLCAL_TELESCOPE_SCANNING_MODE"
-    dark_average_light_level = "DARK_AVERAGE_LIGHT_LEVEL"
-    solar_gain_average_light_level = "SOLAR_GAIN_AVERAGE_LIGHT_LEVEL"
-    polcal_average_light_level = "POLCAL_AVERAGE_LIGHT_LEVEL"
-    dark_average_telescope_elevation = "DARK_AVERAGE_TELESCOPE_ELEVATION"
-    solar_gain_average_telescope_elevation = "SOLAR_GAIN_AVERAGE_TELESCOPE_ELEVATION"
-    polcal_average_telescope_elevation = "POLCAL_AVERAGE_TELESCOPE_ELEVATION"
-    dark_average_coude_table_angle = "DARK_AVERAGE_COUDE_TABLE_ANGLE"
-    solar_gain_average_coude_table_angle = "SOLAR_GAIN_AVERAGE_COUDE_TABLE_ANGLE"
-    polcal_average_coude_table_angle = "POLCAL_AVERAGE_COUDE_TABLE_ANGLE"
-    dark_average_telescope_azimuth = "DARK_AVERAGE_TELESCOPE_AZIMUTH"
-    solar_gain_average_telescope_azimuth = "SOLAR_GAIN_AVERAGE_TELESCOPE_AZIMUTH"
-    polcal_average_telescope_azimuth = "POLCAL_AVERAGE_TELESCOPE_AZIMUTH"
-    dark_gos_level3_status = "DARK_GOS_LEVEL3_STATUS"
-    solar_gain_gos_level3_status = "SOLAR_GAIN_GOS_LEVEL3_STATUS"
-    dark_gos_level3_lamp_status = "DARK_GOS_LEVEL3_LAMP_STATUS"
-    solar_gain_gos_level3_lamp_status = "SOLAR_GAIN_GOS_LEVEL3_LAMP_STATUS"
-    dark_gos_polarizer_status = "DARK_GOS_POLARIZER_STATUS"
-    solar_gain_gos_polarizer_status = "SOLAR_GAIN_GOS_POLARIZER_STATUS"
-    dark_gos_polarizer_angle = "DARK_GOS_POLARIZER_ANGLE"
-    solar_gain_gos_polarizer_angle = "SOLAR_GAIN_GOS_POLARIZER_ANGLE"
-    dark_gos_retarder_status = "DARK_GOS_RETARDER_STATUS"
-    solar_gain_gos_retarder_status = "SOLAR_GAIN_GOS_RETARDER_STATUS"
-    dark_gos_retarder_angle = "DARK_GOS_RETARDER_ANGLE"
-    solar_gain_gos_retarder_angle = "SOLAR_GAIN_GOS_RETARDER_ANGLE"
-    dark_gos_level0_status = "DARK_GOS_LEVEL0_STATUS"
-    solar_gain_gos_level0_status = "SOLAR_GAIN_GOS_LEVEL0_STATUS"
 
 
 class ConstantsBase:
@@ -145,11 +87,11 @@ class ConstantsBase:
 
     @property
     def dataset_id(self) -> str:
-        """Define the dataset id constant."""
+        """Define the dataset_id constant."""
         return Sqids(min_length=6, alphabet=ascii_uppercase).encode([self._recipe_run_id])
 
     @property
-    def stokes_params(self) -> list[str]:
+    def stokes_params(self) -> [str]:
         """Return the list of stokes parameter names."""
         return ["I", "Q", "U", "V"]
 
@@ -159,41 +101,45 @@ class ConstantsBase:
         return self._db_dict[BudName.instrument]
 
     @property
-    def num_cs_steps(self) -> int:
+    def num_cs_steps(self):
         """Get the number of calibration sequence steps."""
         return self._db_dict[BudName.num_cs_steps]
 
     @property
-    def num_modstates(self) -> int:
+    def num_modstates(self):
         """Get the number of modulation states."""
         return self._db_dict[BudName.num_modstates]
 
     @property
-    def retarder_name(self) -> str:
+    def retarder_name(self):
         """Get the retarder name."""
         return self._db_dict[BudName.retarder_name]
 
     @property
     def proposal_id(self) -> str:
-        """Get the proposal ID constant."""
+        """Get the proposal_id constant."""
         return self._db_dict[BudName.proposal_id]
 
     @property
-    def contributing_proposal_ids(self) -> list[str]:
+    def contributing_proposal_ids(self) -> [str]:
         """Return the list of contributing proposal IDs."""
         proposal_ids = self._db_dict[BudName.contributing_proposal_ids]
-        return list(proposal_ids)
+        if isinstance(proposal_ids, str):
+            return [proposal_ids]
+        return proposal_ids
 
     @property
     def experiment_id(self) -> str:
-        """Get the experiment ID constant."""
+        """Get the experiment_id constant."""
         return self._db_dict[BudName.experiment_id]
 
     @property
-    def contributing_experiment_ids(self) -> list[str]:
+    def contributing_experiment_ids(self) -> [str]:
         """Return the list of contributing experiment IDs."""
         experiment_ids = self._db_dict[BudName.contributing_experiment_ids]
-        return list(experiment_ids)
+        if isinstance(experiment_ids, str):
+            return [experiment_ids]
+        return experiment_ids
 
     @property
     def obs_ip_start_time(self) -> str:
@@ -202,7 +148,7 @@ class ConstantsBase:
 
     @property
     def average_cadence(self) -> float:
-        """Get the average cadence constant."""
+        """Get the average_cadence constant."""
         return self._db_dict[BudName.average_cadence]
 
     @property
@@ -226,298 +172,16 @@ class ConstantsBase:
         return self._db_dict[BudName.num_dsps_repeats]
 
     @property
-    def dark_exposure_times(self) -> list[float]:
+    def dark_exposure_times(self) -> [float]:
         """Get a list of exposure times used in the dark calibration."""
-        exposure_times = self._db_dict[BudName.dark_exposure_times]
-        return list(exposure_times)
+        return self._db_dict[BudName.dark_exposure_times]
 
     @property
-    def dark_readout_exp_times(self) -> list[float]:
-        """Get a list of readout exp times for all dark frames."""
-        readout_times = self._db_dict[BudName.dark_readout_exp_times]
-        return list(readout_times)
+    def dark_readout_exp_times(self) -> [float]:
+        """Get a list of readout exp times for all DARK frames."""
+        return self._db_dict[BudName.dark_readout_exp_times]
 
     @property
     def wavelength(self) -> float:
         """Wavelength."""
         return self._db_dict[BudName.wavelength]
-
-    @property
-    def camera_id(self) -> str:
-        """Return the camera ID constant."""
-        return self._db_dict[BudName.camera_id]
-
-    @property
-    def camera_name(self) -> str:
-        """Return the camera name for humans constant."""
-        return self._db_dict[BudName.camera_name]
-
-    @property
-    def camera_bit_depth(self) -> int:
-        """Return the camera bit depth constant."""
-        return self._db_dict[BudName.camera_bit_depth]
-
-    @property
-    def hardware_binning_x(self) -> int:
-        """Return the x-direction hardware binning constant."""
-        return self._db_dict[BudName.hardware_binning_x]
-
-    @property
-    def hardware_binning_y(self) -> int:
-        """Return the y-direction hardware binning constant."""
-        return self._db_dict[BudName.hardware_binning_y]
-
-    @property
-    def software_binning_x(self) -> int:
-        """Return the x-direction software binning constant."""
-        return self._db_dict[BudName.software_binning_x]
-
-    @property
-    def software_binning_y(self) -> int:
-        """Return the y-direction software binning constant."""
-        return self._db_dict[BudName.software_binning_y]
-
-    @property
-    def hls_version(self) -> str:
-        """Return the High-Level Software version."""
-        return self._db_dict[BudName.hls_version]
-
-    # Multi-task constants start here:
-
-    @property
-    def dark_observing_program_execution_id(self) -> list[str]:
-        """Return the observing program execution id constant for the dark task."""
-        observing_programs = self._db_dict[BudName.dark_observing_program_execution_id]
-        return list(observing_programs)
-
-    @property
-    def solar_gain_observing_program_execution_id(self) -> list[str]:
-        """Return the observing program execution id constant for the solar_gain task."""
-        observing_programs = self._db_dict[BudName.solar_gain_observing_program_execution_id]
-        return list(observing_programs)
-
-    @property
-    def polcal_observing_program_execution_id(self) -> list[str]:
-        """Return the observing program execution id constant."""
-        observing_programs = self._db_dict[BudName.polcal_observing_program_execution_id]
-        return list(observing_programs)
-
-    @property
-    def dark_date_begin(self) -> str:
-        """Return the date begin header constant for the dark task."""
-        return self._db_dict[BudName.dark_date_begin]
-
-    @property
-    def solar_gain_date_begin(self) -> str:
-        """Return the date begin header constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_date_begin]
-
-    @property
-    def polcal_date_begin(self) -> str:
-        """Return the time obs header constant for the polcal task."""
-        return self._db_dict[BudName.polcal_date_begin]
-
-    @property
-    def dark_date_end(self) -> str:
-        """Return the date end constant for the dark task."""
-        return self._db_dict[BudName.dark_date_end]
-
-    @property
-    def solar_gain_date_end(self) -> str:
-        """Return the date end constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_date_end]
-
-    @property
-    def polcal_date_end(self) -> str:
-        """Return the date end constant for the polcal task."""
-        return self._db_dict[BudName.polcal_date_end]
-
-    @property
-    def dark_num_raw_frames_per_fpa(self) -> int:
-        """Return the number of raw frames per fpa constant for the dark task."""
-        return self._db_dict[BudName.dark_num_raw_frames_per_fpa]
-
-    @property
-    def solar_gain_num_raw_frames_per_fpa(self) -> int:
-        """Return the number of raw frames per fpa constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_num_raw_frames_per_fpa]
-
-    @property
-    def polcal_num_raw_frames_per_fpa(self) -> int:
-        """Return the num raw frames per fpa constant for the polcal task."""
-        return self._db_dict[BudName.polcal_num_raw_frames_per_fpa]
-
-    @property
-    def dark_telescope_tracking_mode(self) -> str:
-        """Return the telescope tracking mode constant for the dark task."""
-        return self._db_dict[BudName.dark_telescope_tracking_mode]
-
-    @property
-    def solar_gain_telescope_tracking_mode(self) -> str:
-        """Return the telescope tracking mode constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_telescope_tracking_mode]
-
-    @property
-    def polcal_telescope_tracking_mode(self) -> str:
-        """Return the telescope tracking mode constant for the polcal task."""
-        return self._db_dict[BudName.polcal_telescope_tracking_mode]
-
-    @property
-    def dark_coude_table_tracking_mode(self) -> str:
-        """Return the coude table tracking mode constant for the dark task."""
-        return self._db_dict[BudName.dark_coude_table_tracking_mode]
-
-    @property
-    def solar_gain_coude_table_tracking_mode(self) -> str:
-        """Return the coude table tracking mode constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_coude_table_tracking_mode]
-
-    @property
-    def polcal_coude_table_tracking_mode(self) -> str:
-        """Return the coude table tracking mode constant for the polcal task."""
-        return self._db_dict[BudName.polcal_coude_table_tracking_mode]
-
-    @property
-    def dark_telescope_scanning_mode(self) -> str:
-        """Return the telescope scanning mode constant for the dark task."""
-        return self._db_dict[BudName.dark_telescope_scanning_mode]
-
-    @property
-    def solar_gain_telescope_scanning_mode(self) -> str:
-        """Return the telescope scanning mode constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_telescope_scanning_mode]
-
-    @property
-    def polcal_telescope_scanning_mode(self) -> str:
-        """Return the telescope scanning mode constant for the polcal task."""
-        return self._db_dict[BudName.polcal_telescope_scanning_mode]
-
-    @property
-    def dark_average_light_level(self) -> float:
-        """Return the average light level constant for the dark task."""
-        return self._db_dict[BudName.dark_average_light_level]
-
-    @property
-    def solar_gain_average_light_level(self) -> float:
-        """Return the average light level constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_average_light_level]
-
-    @property
-    def polcal_average_light_level(self) -> float:
-        """Return the average light level constant for the polcal task."""
-        return self._db_dict[BudName.polcal_average_light_level]
-
-    @property
-    def dark_average_telescope_elevation(self) -> float:
-        """Return the average telescope elevation constant for the dark task."""
-        return self._db_dict[BudName.dark_average_telescope_elevation]
-
-    @property
-    def solar_gain_average_telescope_elevation(self) -> float:
-        """Return the average telescope elevation constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_average_telescope_elevation]
-
-    @property
-    def polcal_average_telescope_elevation(self) -> float:
-        """Return the average telescope elevation constant for the polcal task."""
-        return self._db_dict[BudName.polcal_average_telescope_elevation]
-
-    @property
-    def dark_average_coude_table_angle(self) -> float:
-        """Return the average coude table angle constant for the dark task."""
-        return self._db_dict[BudName.dark_average_coude_table_angle]
-
-    @property
-    def solar_gain_average_coude_table_angle(self) -> float:
-        """Return the average coude table angle constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_average_coude_table_angle]
-
-    @property
-    def polcal_average_coude_table_angle(self) -> float:
-        """Return the average coude table angle constant for the polcal task."""
-        return self._db_dict[BudName.polcal_average_coude_table_angle]
-
-    @property
-    def dark_average_telescope_azimuth(self) -> float:
-        """Return the average telescope azimuth constant for the dark task."""
-        return self._db_dict[BudName.dark_average_telescope_azimuth]
-
-    @property
-    def solar_gain_average_telescope_azimuth(self) -> float:
-        """Return the average telescope azimuth constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_average_telescope_azimuth]
-
-    @property
-    def polcal_average_telescope_azimuth(self) -> float:
-        """Return the average telescope azimuth constant for the polcal task."""
-        return self._db_dict[BudName.polcal_average_telescope_azimuth]
-
-    @property
-    def dark_gos_level3_status(self) -> str:
-        """Return the gos level3 status constant for the dark task."""
-        return self._db_dict[BudName.dark_gos_level3_status]
-
-    @property
-    def solar_gain_gos_level3_status(self) -> str:
-        """Return the gos level3 status constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_gos_level3_status]
-
-    @property
-    def dark_gos_level3_lamp_status(self) -> str:
-        """Return the gos level3 lamp status constant for the dark task."""
-        return self._db_dict[BudName.dark_gos_level3_lamp_status]
-
-    @property
-    def solar_gain_gos_level3_lamp_status(self) -> str:
-        """Return the gos level3 lamp status constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_gos_level3_lamp_status]
-
-    @property
-    def dark_gos_polarizer_status(self) -> str:
-        """Return the gos polarizer status constant for the dark task."""
-        return self._db_dict[BudName.dark_gos_polarizer_status]
-
-    @property
-    def solar_gain_gos_polarizer_status(self) -> str:
-        """Return the gos polarizer status constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_gos_polarizer_status]
-
-    @property
-    def dark_gos_polarizer_angle(self) -> float:
-        """Return the gos polarizer angle constant for the dark task."""
-        return self._db_dict[BudName.dark_gos_polarizer_angle]
-
-    @property
-    def solar_gain_gos_polarizer_angle(self) -> float:
-        """Return the gos polarizer angle constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_gos_polarizer_angle]
-
-    @property
-    def dark_gos_retarder_status(self) -> str:
-        """Return the gos retarder status constant for the dark task."""
-        return self._db_dict[BudName.dark_gos_retarder_status]
-
-    @property
-    def solar_gain_gos_retarder_status(self) -> str:
-        """Return the gos retarder status constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_gos_retarder_status]
-
-    @property
-    def dark_gos_retarder_angle(self) -> float:
-        """Return the gos retarder angle constant for the dark task."""
-        return self._db_dict[BudName.dark_gos_retarder_angle]
-
-    @property
-    def solar_gain_gos_retarder_angle(self) -> float:
-        """Return the gos retarder angle constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_gos_retarder_angle]
-
-    @property
-    def dark_gos_level0_status(self) -> str:
-        """Return the gos level0 status constant for the dark task."""
-        return self._db_dict[BudName.dark_gos_level0_status]
-
-    @property
-    def solar_gain_gos_level0_status(self) -> str:
-        """Return the gos level0 status constant for the solar gain task."""
-        return self._db_dict[BudName.solar_gain_gos_level0_status]

dkist_processing_common/models/fits_access.py

@@ -3,16 +3,15 @@
 from __future__ import annotations
 
 from enum import StrEnum
-from enum import unique
 from pathlib import Path
+from typing import Any
 
 import numpy as np
 from astropy.io import fits
 
-HEADER_KEY_NOT_FOUND = "HEADER_KEY_NOT_FOUND"
+NOT_FOUND_MESSAGE = "_HEADER_KEYWORD_NOT_FOUND"
 
 
-@unique
 class MetadataKey(StrEnum):
     """Controlled list of names for FITS metadata header keys."""
 
@@ -40,19 +39,6 @@ class MetadataKey(StrEnum):
     fpa_exposure_time_ms = "XPOSURE"
     sensor_readout_exposure_time_ms = "TEXPOSUR"
     num_raw_frames_per_fpa = "NSUMEXP"
-    camera_id = "CAM_ID"
-    camera_name = "CAMERA"
-    camera_bit_depth = "BITDEPTH"
-    hardware_binning_x = "HWBIN1"
-    hardware_binning_y = "HWBIN2"
-    software_binning_x = "SWBIN1"
-    software_binning_y = "SWBIN2"
-    observing_program_execution_id = "OBSPR_ID"
-    telescope_tracking_mode = "TELTRACK"
-    coude_table_tracking_mode = "TTBLTRCK"
-    telescope_scanning_mode = "TELSCAN"
-    light_level = "LIGHTLVL"
-    hls_version = "HLSVERS"
 
 
 class FitsAccessBase:
@@ -82,6 +68,29 @@ class FitsAccessBase:
     def __repr__(self):
         return f"{self.__class__.__name__}(hdu={self._hdu!r}, name={self.name!r}, auto_squeeze={self.auto_squeeze})"
 
+    def _set_metadata_key_value(
+        self, key: StrEnum, optional: bool = False, default: Any = NOT_FOUND_MESSAGE
+    ) -> None:
+        """
+        Get the header value and assign it as a metadata key name attribute.
+
+        Parameters
+        ----------
+        key
+            The StrEnum member in attribute_name = fits_keyword structure
+        optional
+            If the keyword is optional
+        default
+            Value for the attribute if the key is not found
+        """
+        if optional:
+            if default != NOT_FOUND_MESSAGE:
+                setattr(self, key.name, self.header.get(key, default))
+            else:
+                setattr(self, key.name, self.header.get(key, key + NOT_FOUND_MESSAGE))
+        else:
+            setattr(self, key.name, self.header[key])
+
     @property
     def data(self) -> np.ndarray:
         """

dkist_processing_common/parsers/experiment_id_bud.py

@@ -2,19 +2,16 @@
 
 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.unique_bud import TaskUniqueBud
+from dkist_processing_common.parsers.id_bud import IdBud
 
 
-class ExperimentIdBud(TaskUniqueBud):
+class ExperimentIdBud(IdBud):
     """Class to create a Bud for the experiment_id."""
 
     def __init__(self):
         super().__init__(
-            constant_name=BudName.experiment_id,
-            metadata_key=MetadataKey.experiment_id,
-            ip_task_types=TaskName.observe,
+            constant_name=BudName.experiment_id, metadata_key=MetadataKey.experiment_id
         )
 
 
@@ -23,6 +20,5 @@ class ContributingExperimentIdsBud(ContributingIdsBud):
 
     def __init__(self):
         super().__init__(
-            constant_name=BudName.contributing_experiment_ids,
-            metadata_key=MetadataKey.experiment_id,
+            stem_name=BudName.contributing_experiment_ids, metadata_key=MetadataKey.experiment_id
         )

dkist_processing_common/parsers/id_bud.py

@@ -1,25 +1,36 @@
 """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 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.task import passthrough_header_ip_task
+from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
+
+
+class IdBud(TaskUniqueBud):
+    """Base class for ID buds."""
+
+    def __init__(self, constant_name: str, metadata_key: str | StrEnum):
+        super().__init__(
+            constant_name=constant_name,
+            metadata_key=metadata_key,
+            ip_task_types=TaskName.observe,
+        )
 
 
 class ContributingIdsBud(Stem):
     """Base class for contributing ID buds."""
 
-    def __init__(self, constant_name: str, metadata_key: str | StrEnum):
-        super().__init__(stem_name=constant_name)
+    def __init__(self, stem_name: str, metadata_key: str | StrEnum):
+        super().__init__(stem_name=stem_name)
         if isinstance(metadata_key, StrEnum):
             metadata_key = metadata_key.name
         self.metadata_key = metadata_key
 
-    def setter(self, fits_obj: L0FitsAccess) -> str:
+    def setter(self, fits_obj: L0FitsAccess) -> str | Type[SpilledDirt]:
         """
         Set the id for any type of frame.
 
@@ -33,9 +44,9 @@ class ContributingIdsBud(Stem):
         """
         return getattr(fits_obj, self.metadata_key)
 
-    def getter(self, key) -> tuple[str, ...]:
+    def getter(self, key) -> tuple:
         """
-        Get all ids seen for any type of frame.
+        Get all ids seen in non observe frames.
 
         Parameters
         ----------
@@ -44,33 +55,6 @@ class ContributingIdsBud(Stem):
 
         Returns
         -------
-        IDs from all types of frames
+        IDs from non observe frames
         """
         return tuple(set(self.key_to_petal_dict.values()))
-
-
-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

@@ -27,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[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]
+        self._set_metadata_key_value(MetadataKey.ip_task_type)
+        self._set_metadata_key_value(MetadataKey.ip_start_time)
+        self._set_metadata_key_value(MetadataKey.ip_end_time)