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

dkist_processing_common/tests/test_stems.py

@@ -1,63 +1,115 @@
+import collections
+from enum import StrEnum
+from itertools import chain
+
 import pytest
 from astropy.io import fits
 
 from dkist_processing_common.models.constants import BudName
 from dkist_processing_common.models.fits_access import FitsAccessBase
+from dkist_processing_common.models.fits_access import MetadataKey
 from dkist_processing_common.models.tags import StemName
 from dkist_processing_common.models.task_name import TaskName
+from dkist_processing_common.parsers.average_bud import TaskAverageBud
 from dkist_processing_common.parsers.cs_step import CSStepFlower
 from dkist_processing_common.parsers.cs_step import NumCSStepBud
 from dkist_processing_common.parsers.dsps_repeat import DspsRepeatNumberFlower
 from dkist_processing_common.parsers.dsps_repeat import TotalDspsRepeatsBud
 from dkist_processing_common.parsers.experiment_id_bud import ContributingExperimentIdsBud
 from dkist_processing_common.parsers.experiment_id_bud import ExperimentIdBud
+from dkist_processing_common.parsers.id_bud import TaskContributingIdsBud
+from dkist_processing_common.parsers.lookup_bud import TaskTimeLookupBud
+from dkist_processing_common.parsers.lookup_bud import TimeLookupBud
 from dkist_processing_common.parsers.near_bud import NearFloatBud
 from dkist_processing_common.parsers.near_bud import TaskNearFloatBud
+from dkist_processing_common.parsers.observing_program_id_bud import (
+    TaskContributingObservingProgramExecutionIdsBud,
+)
 from dkist_processing_common.parsers.proposal_id_bud import ContributingProposalIdsBud
 from dkist_processing_common.parsers.proposal_id_bud import ProposalIdBud
+from dkist_processing_common.parsers.retarder import RetarderNameBud
 from dkist_processing_common.parsers.single_value_single_key_flower import (
     SingleValueSingleKeyFlower,
 )
-from dkist_processing_common.parsers.task import parse_header_ip_task_with_gains
 from dkist_processing_common.parsers.task import PolcalTaskFlower
 from dkist_processing_common.parsers.task import TaskTypeFlower
+from dkist_processing_common.parsers.task import parse_header_ip_task_with_gains
 from dkist_processing_common.parsers.time import AverageCadenceBud
 from dkist_processing_common.parsers.time import ExposureTimeFlower
 from dkist_processing_common.parsers.time import MaximumCadenceBud
 from dkist_processing_common.parsers.time import MinimumCadenceBud
 from dkist_processing_common.parsers.time import ObsIpStartTimeBud
 from dkist_processing_common.parsers.time import ReadoutExpTimeFlower
+from dkist_processing_common.parsers.time import TaskDateBeginBud
+from dkist_processing_common.parsers.time import TaskDatetimeBudBase
 from dkist_processing_common.parsers.time import TaskExposureTimesBud
 from dkist_processing_common.parsers.time import TaskReadoutExpTimesBud
+from dkist_processing_common.parsers.time import TaskRoundTimeBudBase
 from dkist_processing_common.parsers.time import VarianceCadenceBud
 from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
 from dkist_processing_common.parsers.unique_bud import UniqueBud
 from dkist_processing_common.parsers.wavelength import ObserveWavelengthBud
 
 
+class FitsReaderMetadataKey(StrEnum):
+    thing_id = "id_key"
+    constant_thing = "constant"
+    near_thing = "near"
+    proposal_id = "ID___013"
+    experiment_id = "ID___012"
+    observing_program_execution_id = "ID___008"
+    ip_task_type = "DKIST004"
+    ip_start_time = "DKIST011"
+    fpa_exposure_time_ms = "XPOSURE"
+    sensor_readout_exposure_time_ms = "TEXPOSUR"
+    num_raw_frames_per_fpa = "NSUMEXP"
+    num_dsps_repeats = "DSPSREPS"
+    current_dsps_repeat = "DSPSNUM"
+    time_obs = "DATE-OBS"
+    gos_level3_status = "GOSLVL3"
+    gos_level3_lamp_status = "GOSLAMP"
+    gos_level0_status = "GOSLVL0"
+    gos_retarder_status = "GOSRET"
+    gos_polarizer_status = "GOSPOL"
+    wavelength = "LINEWAV"
+    roundable_time = "RTIME"
+
+
 class FitsReader(FitsAccessBase):
     def __init__(self, hdu, name):
         super().__init__(hdu, name)
-        self.thing_id: int = self.header.get("id_key")
-        self.constant_thing: float = self.header.get("constant")
-        self.near_thing: float = self.header.get("near")
+        self.thing_id: int = self.header.get(FitsReaderMetadataKey.thing_id)
+        self.constant_thing: int = self.header.get(FitsReaderMetadataKey.constant_thing)
+        self.near_thing: float = self.header.get(FitsReaderMetadataKey.near_thing)
         self.name = name
-        self.proposal_id: str = self.header.get("ID___013")
-        self.experiment_id: str = self.header.get("ID___012")
-        self.ip_task_type: str = self.header.get("DKIST004")
-        self.ip_start_time: str = self.header.get("DKIST011")
-        self.fpa_exposure_time_ms: float = self.header.get("XPOSURE")
-        self.sensor_readout_exposure_time_ms: float = self.header.get("TEXPOSUR")
-        self.num_raw_frames_per_fpa: int = self.header.get("NSUMEXP")
-        self.num_dsps_repeats: int = self.header.get("DSPSREPS")
-        self.current_dsps_repeat: int = self.header.get("DSPSNUM")
-        self.time_obs: str = self.header.get("DATE-OBS")
-        self.gos_level3_status: str = self.header.get("GOSLVL3")
-        self.gos_level3_lamp_status: str = self.header.get("GOSLAMP")
-        self.gos_level0_status: str = self.header.get("GOSLVL0")
-        self.gos_retarder_status: str = self.header.get("GOSRET")
-        self.gos_polarizer_status: str = self.header.get("GOSPOL")
-        self.wavelength: str = self.header.get("LINEWAV")
+        self.proposal_id: str = self.header.get(FitsReaderMetadataKey.proposal_id)
+        self.experiment_id: str = self.header.get(FitsReaderMetadataKey.experiment_id)
+        self.observing_program_execution_id: str = self.header.get(
+            FitsReaderMetadataKey.observing_program_execution_id
+        )
+        self.ip_task_type: str = self.header.get(FitsReaderMetadataKey.ip_task_type)
+        self.ip_start_time: str = self.header.get(FitsReaderMetadataKey.ip_start_time)
+        self.fpa_exposure_time_ms: float = self.header.get(
+            FitsReaderMetadataKey.fpa_exposure_time_ms
+        )
+        self.sensor_readout_exposure_time_ms: float = self.header.get(
+            FitsReaderMetadataKey.sensor_readout_exposure_time_ms
+        )
+        self.num_raw_frames_per_fpa: int = self.header.get(
+            FitsReaderMetadataKey.num_raw_frames_per_fpa
+        )
+        self.num_dsps_repeats: int = self.header.get(FitsReaderMetadataKey.num_dsps_repeats)
+        self.current_dsps_repeat: int = self.header.get(FitsReaderMetadataKey.current_dsps_repeat)
+        self.time_obs: str = self.header.get(FitsReaderMetadataKey.time_obs)
+        self.gos_level3_status: str = self.header.get(FitsReaderMetadataKey.gos_level3_status)
+        self.gos_level3_lamp_status: str = self.header.get(
+            FitsReaderMetadataKey.gos_level3_lamp_status
+        )
+        self.gos_level0_status: str = self.header.get(FitsReaderMetadataKey.gos_level0_status)
+        self.gos_retarder_status: str = self.header.get(FitsReaderMetadataKey.gos_retarder_status)
+        self.gos_polarizer_status: str = self.header.get(FitsReaderMetadataKey.gos_polarizer_status)
+        self.wavelength: str = self.header.get(FitsReaderMetadataKey.wavelength)
+        self.roundable_time: float = self.header.get(FitsReaderMetadataKey.roundable_time, 0.0)
 
 
 @pytest.fixture()
@@ -71,6 +123,7 @@ def basic_header_objs():
                 "DKIST004": "observe",
                 "ID___012": "experiment_id_1",
                 "ID___013": "proposal_id_1",
+                "ID___008": "observing_program_execution_id_1",
                 "XPOSURE": 0.0013000123,
                 "TEXPOSUR": 10.0,
                 "NSUMEXP": 3,
@@ -89,6 +142,7 @@ def basic_header_objs():
                 "DKIST004": "observe",
                 "ID___012": "experiment_id_1",
                 "ID___013": "proposal_id_1",
+                "ID___008": "observing_program_execution_id_2",
                 "XPOSURE": 0.0013000987,
                 "TEXPOSUR": 10.0,
                 "NSUMEXP": 3,
@@ -97,6 +151,7 @@ def basic_header_objs():
                 "DATE-OBS": "2022-06-17T22:00:01.000",
                 "DKIST011": "2023-09-28T10:23.000",
                 "LINEWAV": 666.0,
+                "GOSRET": "incorrect",
             }
         ),
         "thing2": fits.header.Header(
@@ -107,6 +162,7 @@ def basic_header_objs():
                 "DKIST004": "dark",
                 "ID___012": "experiment_id_2",
                 "ID___013": "proposal_id_2",
+                "ID___008": "observing_program_execution_id_2",
                 "XPOSURE": 12.345,
                 "TEXPOSUR": 1.123456789,
                 "NSUMEXP": 1,
@@ -115,6 +171,8 @@ def basic_header_objs():
                 "DATE-OBS": "2022-06-17T22:00:02.000",
                 "DKIST011": "1903-01-01T12:00.000",
                 "LINEWAV": 0.0,
+                "GOSRET": "wrong",
+                "RTIME": 2.3400000009999,
             }
         ),
         "thing3": fits.header.Header(
@@ -125,6 +183,7 @@ def basic_header_objs():
                 "DKIST004": "observe",
                 "ID___012": "experiment_id_1",
                 "ID___013": "proposal_id_1",
+                "ID___008": "observing_program_execution_id_1",
                 "XPOSURE": 100.0,
                 "TEXPOSUR": 11.0,
                 "NSUMEXP": 4,
@@ -133,6 +192,28 @@ def basic_header_objs():
                 "DATE-OBS": "2022-06-17T22:00:03.000",
                 "DKIST011": "2023-09-28T10:23.000",
                 "LINEWAV": 666.0,
+                "GOSRET": "clear",
+            },
+        ),
+        "thing4": fits.header.Header(
+            {
+                "DKIST004": "gain",
+                "ID___013": "proposal_id_1",
+                "ID___008": "observing_program_execution_id_1",
+                "id_key": 0,
+                "constant": 6.28,
+                "near": 1.23,
+                "ID___012": "experiment_id_1",
+                "XPOSURE": 100.0,
+                "TEXPOSUR": 11.0,
+                "NSUMEXP": 5,
+                "DSPSNUM": 2,
+                "DSPSREPS": 2,
+                "DATE-OBS": "2022-06-17T22:00:03.000",
+                "DKIST011": "2023-09-28T10:23.000",
+                "LINEWAV": 666.0,
+                "GOSRET": "clear",
+                "RTIME": 2.340000004444,
             }
         ),
     }
@@ -150,7 +231,12 @@ def task_with_gains_header_objs():
 
 
 @pytest.fixture
-def task_with_polcal_header_objs():
+def retarder_name():
+    return "Foo Bar"
+
+
+@pytest.fixture
+def task_with_polcal_header_objs(retarder_name):
     header_dict = {
         "polcal_dark": fits.header.Header(
             {"DKIST004": "polcal", "GOSLVL0": "DarkShutter", "GOSPOL": "clear", "GOSRET": "clear"}
@@ -158,7 +244,9 @@ def task_with_polcal_header_objs():
         "polcal_gain": fits.header.Header(
             {"DKIST004": "polcal", "GOSLVL0": "FieldStop", "GOSPOL": "clear", "GOSRET": "clear"}
         ),
-        "just_polcal": fits.header.Header({"DKIST004": "polcal", "GOSLVL0": "something"}),
+        "just_polcal": fits.header.Header(
+            {"DKIST004": "polcal", "GOSLVL0": "something", "GOSRET": retarder_name}
+        ),
     }
     return (FitsReader.from_header(header, name=path) for path, header in header_dict.items())
 
@@ -190,28 +278,61 @@ def bad_header_objs():
                 "LINEWAV": 1.0,
             }
         ),
+        "thing2": fits.header.Header(
+            {
+                "id_key": 1,
+                "constant": 2.78,
+                "near": 1.76,
+                "DKIST004": "gain",
+                "DSPSREPS": 2,
+                "DSPSNUM": 2,
+                "DATE-OBS": "2022-06-17T22:00:03.000",
+                "LINEWAV": 1.0,
+            }
+        ),
+        "thing4": fits.header.Header(
+            {
+                "id_key": 1,
+                "constant": 6.66,
+                "near": 1.76,
+                "DKIST004": "dark",
+                "DSPSREPS": 2,
+                "DSPSNUM": 2,
+                "DATE-OBS": "2022-06-17T22:00:03.000",
+                "LINEWAV": 1.0,
+            }
+        ),
     }
     return (FitsReader.from_header(header, name=path) for path, header in bad_headers.items())
 
 
+@pytest.fixture
+def bad_polcal_header_objs():
+    # I.e., GOSRET has multiple values
+    header_dict = {
+        "thing1": fits.header.Header({"DKIST004": "polcal", "GOSRET": "clear"}),
+        "thing2": fits.header.Header({"DKIST004": "polcal", "GOSRET": "RET1"}),
+        "thing3": fits.header.Header({"DKIST004": "polcal", "GOSRET": "RET2"}),
+    }
+    return (FitsReader.from_header(header, name=path) for path, header in header_dict.items())
+
+
 def test_unique_bud(basic_header_objs):
     """
     Given: A set of headers with a constant value header key
     When: Ingesting headers with a UniqueBud and asking for the value
     Then: The Bud's value is the header constant value
     """
-    bud = UniqueBud(
+    bud_obj = UniqueBud(
         constant_name="constant",
         metadata_key="constant_thing",
     )
-    assert bud.stem_name == "constant"
+    assert bud_obj.stem_name == "constant"
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
 
-    petal = list(bud.petals)
-    assert len(petal) == 1
-    assert petal[0].value == 6.28
+    assert bud_obj.bud.value == 6.28
 
 
 def test_unique_bud_non_unique_inputs(bad_header_objs):
@@ -220,54 +341,66 @@ def test_unique_bud_non_unique_inputs(bad_header_objs):
     When: Ingesting headers with a UniqueBud and asking for the value
     Then: An error is raised
     """
-    bud = UniqueBud(
+    bud_obj = UniqueBud(
         constant_name="constant",
         metadata_key="constant_thing",
     )
-    assert bud.stem_name == "constant"
+    assert bud_obj.stem_name == "constant"
     for fo in bad_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
 
-    with pytest.raises(ValueError):
-        assert next(bud.petals)
+    with pytest.raises(ValueError, match="Multiple constant values found! Values:"):
+        _ = bud_obj.bud
 
 
-def test_task_unique_bud(basic_header_objs):
+@pytest.mark.parametrize(
+    "ip_task_type",
+    [
+        pytest.param("observe", id="single_task_type"),
+        pytest.param(["observe", "gain"], id="task_type_list"),
+    ],
+)
+def test_task_unique_bud(basic_header_objs, ip_task_type):
     """
     Given: A set of headers with a constant value header key
     When: Ingesting headers with a TaskUniqueBud and asking for the value
     Then: The bud's value is the header constant value
     """
-    bud = TaskUniqueBud(
-        constant_name="proposal", metadata_key="proposal_id", ip_task_type="observe"
+    bud_obj = TaskUniqueBud(
+        constant_name="proposal", metadata_key="proposal_id", ip_task_types=ip_task_type
     )
-    assert bud.stem_name == "proposal"
+    assert bud_obj.stem_name == "proposal"
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
 
-    petal = list(bud.petals)
-    assert len(petal) == 1
-    assert petal[0].value == "proposal_id_1"
+    assert bud_obj.bud.value == "proposal_id_1"
 
 
-def test_task_unique_bud_non_unique_inputs(bad_header_objs):
+@pytest.mark.parametrize(
+    "ip_task_type",
+    [
+        pytest.param("observe", id="single_task_type"),
+        pytest.param(["dark", "gain"], id="task_type_list"),
+    ],
+)
+def test_task_unique_bud_non_unique_inputs(bad_header_objs, ip_task_type):
     """
     Given: A set of headers with a non-constant header key that is expected to be constant
     When: Ingesting headers with a UniqueBud and asking for the value
     Then: An error is raised
     """
     bud = TaskUniqueBud(
-        constant_name="constant", metadata_key="constant_thing", ip_task_type="observe"
+        constant_name="constant", metadata_key="constant_thing", ip_task_types=ip_task_type
     )
     assert bud.stem_name == "constant"
     for fo in bad_header_objs:
         key = fo.name
         bud.update(key, fo)
 
-    with pytest.raises(ValueError):
-        assert next(bud.petals)
+    with pytest.raises(ValueError, match="Multiple constant values found! Values:"):
+        _ = bud.bud
 
 
 def test_single_value_single_key_flower(basic_header_objs):
@@ -285,13 +418,69 @@ def test_single_value_single_key_flower(basic_header_objs):
     petals = sorted(list(flower.petals), key=lambda x: x.value)
     assert len(petals) == 3
     assert petals[0].value == 0
-    assert petals[0].keys == ["thing0", "thing3"]
+    assert petals[0].keys == ["thing0", "thing3", "thing4"]
     assert petals[1].value == 1
     assert petals[1].keys == ["thing1"]
     assert petals[2].value == 2
     assert petals[2].keys == ["thing2"]
 
 
+@pytest.mark.parametrize(
+    "ip_task_type, expected_value",
+    [
+        pytest.param("dark", (1655503202.0,), id="single_task_type"),
+        pytest.param(["dark", "gain"], (1655503202.0, 1655503203.0), id="task_type_list"),
+        pytest.param(
+            ["dark", "gain", "observe"],
+            (1655503200.0, 1655503201.0, 1655503202.0, 1655503203.0, 1655503203.0),
+            id="task_type_list2",
+        ),
+    ],
+)
+def test_task_datetime_base_bud(basic_header_objs, ip_task_type, expected_value):
+    """
+    Given: A set of headers with a datetime value that does not need to be rounded
+    When: Ingesting headers with a `TaskDatetimeBudBase` bud and asking for the value
+    Then: The bud's value is the list of datetimes in seconds
+    """
+    bud_obj = TaskDatetimeBudBase(
+        stem_name="datetimes",
+        metadata_key=FitsReaderMetadataKey.time_obs,
+        ip_task_types=ip_task_type,
+    )
+    assert bud_obj.stem_name == "datetimes"
+    for fo in basic_header_objs:
+        key = fo.name
+        bud_obj.update(key, fo)
+
+    assert bud_obj.bud.value == expected_value
+
+
+@pytest.mark.parametrize(
+    "ip_task_type, expected_value",
+    [
+        pytest.param("dark", (2.34,), id="single_task_type"),
+        pytest.param(["dark", "gain"], (2.34,), id="task_type_list"),
+        pytest.param(["dark", "gain", "observe"], (0.0, 2.34), id="task_type_list2"),
+    ],
+)
+def test_task_round_time_base_bud(basic_header_objs, ip_task_type, expected_value):
+    """
+    Given: A set of headers with a time value that needs to be rounded
+    When: Ingesting headers with a `TaskRoundTimeBudBase` bud and asking for the value
+    Then: The bud's value is the header constant value
+    """
+    bud_obj = TaskRoundTimeBudBase(
+        stem_name="rounded_time", metadata_key="roundable_time", ip_task_types=ip_task_type
+    )
+    assert bud_obj.stem_name == "rounded_time"
+    for fo in basic_header_objs:
+        key = fo.name
+        bud_obj.update(key, fo)
+
+    assert bud_obj.bud.value == expected_value
+
+
 def test_cs_step_flower(grouped_cal_sequence_headers, non_polcal_headers, max_cs_step_time_sec):
     """
     Given: A set of PolCal headers, non-PolCal headers, and the CSStepFlower
@@ -320,17 +509,15 @@ def test_num_cs_step_bud(grouped_cal_sequence_headers, non_polcal_headers, max_c
     When: Updating the NumCSStepBud with all headers
     Then: The bud reports the correct number of CS Steps (thus ignoring the non-PolCal frames)
     """
-    num_cs_bud = NumCSStepBud(max_cs_step_time_sec=max_cs_step_time_sec)
+    num_cs_bud_obj = NumCSStepBud(max_cs_step_time_sec=max_cs_step_time_sec)
     for step, headers in grouped_cal_sequence_headers.items():
         for h in headers:
-            num_cs_bud.update(step, h)
+            num_cs_bud_obj.update(step, h)
 
     for h in non_polcal_headers:
-        num_cs_bud.update("foo", h)
+        num_cs_bud_obj.update("foo", h)
 
-    bud = list(num_cs_bud.petals)
-    assert len(bud) == 1
-    assert bud[0].value == len(grouped_cal_sequence_headers.keys())
+    assert num_cs_bud_obj.bud.value == len(grouped_cal_sequence_headers.keys())
 
 
 def test_proposal_id_bud(basic_header_objs):
@@ -339,15 +526,13 @@ def test_proposal_id_bud(basic_header_objs):
     When: Ingesting the headers with a ProposalIdBud
     Then: The Bud's petal has the correct value
     """
-    bud = ProposalIdBud()
-    assert bud.stem_name == BudName.proposal_id.value
+    bud_obj = ProposalIdBud()
+    assert bud_obj.stem_name == BudName.proposal_id.value
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
 
-    petal = list(bud.petals)
-    assert len(petal) == 1
-    assert petal[0].value == "proposal_id_1"
+    assert bud_obj.bud.value == "proposal_id_1"
 
 
 def test_contributing_proposal_ids_bud(basic_header_objs):
@@ -356,15 +541,13 @@ def test_contributing_proposal_ids_bud(basic_header_objs):
     When: Ingesting the headers with a ContributingProposalIdsBud
     Then: The Bud's petal is the tuple of all input proposal IDs
     """
-    bud = ContributingProposalIdsBud()
-    assert bud.stem_name == BudName.contributing_proposal_ids.value
+    bud_obj = ContributingProposalIdsBud()
+    assert bud_obj.stem_name == BudName.contributing_proposal_ids.value
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
 
-    petal = list(bud.petals)
-    assert len(petal) == 1
-    assert sorted(list(petal[0].value)) == ["proposal_id_1", "proposal_id_2"]
+    assert sorted(list(bud_obj.bud.value)) == ["proposal_id_1", "proposal_id_2"]
 
 
 def test_experiment_id_bud(basic_header_objs):
@@ -373,15 +556,13 @@ def test_experiment_id_bud(basic_header_objs):
     When: Ingesting the headers with a ExperimentIdBud
     Then: The Bud's petal has the correct value
     """
-    bud = ExperimentIdBud()
-    assert bud.stem_name == BudName.experiment_id.value
+    bud_obj = ExperimentIdBud()
+    assert bud_obj.stem_name == BudName.experiment_id.value
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
 
-    petal = list(bud.petals)
-    assert len(petal) == 1
-    assert petal[0].value == "experiment_id_1"
+    assert bud_obj.bud.value == "experiment_id_1"
 
 
 def test_contributing_experiment_ids_bud(basic_header_objs):
@@ -390,15 +571,53 @@ def test_contributing_experiment_ids_bud(basic_header_objs):
     When: Ingesting the headers with a ContributingExperimentIdsBud
     Then: The Bud's petal is the tuple of all input experiment IDs
     """
-    bud = ContributingExperimentIdsBud()
-    assert bud.stem_name == BudName.contributing_experiment_ids.value
+    bud_obj = ContributingExperimentIdsBud()
+    assert bud_obj.stem_name == BudName.contributing_experiment_ids.value
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
 
-    petal = list(bud.petals)
-    assert len(petal) == 1
-    assert sorted(list(petal[0].value)) == ["experiment_id_1", "experiment_id_2"]
+    assert sorted(list(bud_obj.bud.value)) == ["experiment_id_1", "experiment_id_2"]
+
+
+def test_task_contributing_ids_bud(basic_header_objs):
+    """
+    Given: A set of headers with experiment ID values for different tasks
+    When: Ingesting the headers with a TaskContributingIdsBud for the dark task
+    Then: The Bud's petal is just the experiment ID for the dark task
+    """
+    bud_obj = TaskContributingIdsBud(
+        constant_name=BudName.experiment_id,
+        metadata_key=MetadataKey.experiment_id,
+        ip_task_types=TaskName.dark,
+    )
+    assert bud_obj.stem_name == BudName.experiment_id.value
+    for fo in basic_header_objs:
+        key = fo.name
+        bud_obj.update(key, fo)
+
+    assert sorted(list(bud_obj.bud.value)) == ["experiment_id_2"]
+
+
+def test_task_contributing_observing_program_execution_ids_bud(basic_header_objs):
+    """
+    Given: A set of headers with observing program execution ID values for different tasks
+    When: Ingesting the headers with a TaskContributingObservingProgramExecutionIdsBud for a task type
+    Then: The Bud's petal is the observing program execution IDs for the that task type
+    """
+    bud_obj = TaskContributingObservingProgramExecutionIdsBud(
+        constant_name="NOT_A_REAL_BUD",
+        ip_task_types=TaskName.observe,
+    )
+    assert bud_obj.stem_name == "NOT_A_REAL_BUD"
+    for fo in basic_header_objs:
+        key = fo.name
+        bud_obj.update(key, fo)
+
+    assert sorted(list(bud_obj.bud.value)) == [
+        "observing_program_execution_id_1",
+        "observing_program_execution_id_2",
+    ]
 
 
 def test_exp_time_flower(basic_header_objs):
@@ -420,7 +639,7 @@ def test_exp_time_flower(basic_header_objs):
     assert petals[1].value == 12.345
     assert petals[1].keys == ["thing2"]
     assert petals[2].value == 100.0
-    assert petals[2].keys == ["thing3"]
+    assert petals[2].keys == ["thing3", "thing4"]
 
 
 def test_readout_exp_time_flower(basic_header_objs):
@@ -442,7 +661,7 @@ def test_readout_exp_time_flower(basic_header_objs):
     assert petals[1].value == 10.0
     assert petals[1].keys == ["thing0", "thing1"]
     assert petals[2].value == 11.0
-    assert petals[2].keys == ["thing3"]
+    assert petals[2].keys == ["thing3", "thing4"]
 
 
 def test_task_type_flower(task_with_gains_header_objs):
@@ -493,15 +712,13 @@ def test_obs_ip_start_time_bud(basic_header_objs):
     When: Ingesting with a ObsIpStartTimeBud
     Then: The correct value from *only* the observe IP is returned
     """
-    bud = ObsIpStartTimeBud()
-    assert bud.stem_name == BudName.obs_ip_start_time.value
+    bud_obj = ObsIpStartTimeBud()
+    assert bud_obj.stem_name == BudName.obs_ip_start_time.value
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
 
-    petals = list(bud.petals)
-    assert len(petals) == 1
-    assert petals[0].value == "2023-09-28T10:23.000"
+    assert bud_obj.bud.value == "2023-09-28T10:23.000"
 
 
 def test_fpa_exp_times_bud(basic_header_objs):
@@ -510,23 +727,19 @@ def test_fpa_exp_times_bud(basic_header_objs):
     When: Ingesting with a TaskExposureTimesBud
     Then: All (rounded) exposure times are accounted for in the resulting tuple
     """
-    dark_bud = TaskExposureTimesBud(stem_name=BudName.dark_exposure_times, ip_task_type="DARK")
-    obs_bud = TaskExposureTimesBud(stem_name="obs_exp_times", ip_task_type="OBSERVE")
-    assert dark_bud.stem_name == BudName.dark_exposure_times.value
+    dark_bud_obj = TaskExposureTimesBud(stem_name=BudName.dark_exposure_times, ip_task_types="DARK")
+    obs_bud_obj = TaskExposureTimesBud(stem_name="obs_exp_times", ip_task_types="OBSERVE")
+    assert dark_bud_obj.stem_name == BudName.dark_exposure_times.value
     for fo in basic_header_objs:
         key = fo.name
-        dark_bud.update(key, fo)
-        obs_bud.update(key, fo)
+        dark_bud_obj.update(key, fo)
+        obs_bud_obj.update(key, fo)
 
-    dark_petal = list(dark_bud.petals)
-    assert len(dark_petal) == 1
-    assert type(dark_petal[0].value) is tuple
-    assert tuple(sorted(dark_petal[0].value)) == (12.345,)
+    assert type(dark_bud_obj.bud.value) is tuple
+    assert tuple(sorted(dark_bud_obj.bud.value)) == (12.345,)
 
-    obs_petal = list(obs_bud.petals)
-    assert len(obs_petal) == 1
-    assert type(obs_petal[0].value) is tuple
-    assert tuple(sorted(obs_petal[0].value)) == (0.0013, 100.0)
+    assert type(obs_bud_obj.bud.value) is tuple
+    assert tuple(sorted(obs_bud_obj.bud.value)) == (0.0013, 100.0)
 
 
 def test_readout_exp_times_bud(basic_header_objs):
@@ -535,35 +748,36 @@ def test_readout_exp_times_bud(basic_header_objs):
     When: Ingesting with a TaskReadoutExpTimesBud
     Then: All (rounded) exposure times are accounted for in the resulting tuple
     """
-    dark_bud = TaskReadoutExpTimesBud(stem_name=BudName.dark_exposure_times, ip_task_type="DARK")
-    obs_bud = TaskReadoutExpTimesBud(stem_name="obs_exp_times", ip_task_type="OBSERVE")
-    assert dark_bud.stem_name == BudName.dark_exposure_times.value
+    dark_bud_obj = TaskReadoutExpTimesBud(
+        stem_name=BudName.dark_exposure_times, ip_task_types="DARK"
+    )
+    obs_bud_obj = TaskReadoutExpTimesBud(stem_name="obs_exp_times", ip_task_types="OBSERVE")
+    assert dark_bud_obj.stem_name == BudName.dark_exposure_times.value
     for fo in basic_header_objs:
         key = fo.name
-        dark_bud.update(key, fo)
-        obs_bud.update(key, fo)
+        dark_bud_obj.update(key, fo)
+        obs_bud_obj.update(key, fo)
 
-    dark_petal = list(dark_bud.petals)
-    assert len(dark_petal) == 1
-    assert type(dark_petal[0].value) is tuple
-    assert tuple(sorted(dark_petal[0].value)) == (1.123457,)
+    assert type(dark_bud_obj.bud.value) is tuple
+    assert tuple(sorted(dark_bud_obj.bud.value)) == (1.123457,)
 
-    obs_petal = list(obs_bud.petals)
-    assert len(obs_petal) == 1
-    assert type(obs_petal[0].value) is tuple
-    assert tuple(sorted(obs_petal[0].value)) == (10.0, 11.0)
+    assert type(obs_bud_obj.bud.value) is tuple
+    assert tuple(sorted(obs_bud_obj.bud.value)) == (10.0, 11.0)
 
 
 def test_dsps_bud(basic_header_objs):
-    bud = TotalDspsRepeatsBud()
-    assert bud.stem_name == BudName.num_dsps_repeats.value
+    """
+    Given: A set of filepaths and associated headers with DSPSREPS keywords
+    When: Ingesting with a TotalDspsRepeatsBud
+    Then: The total number of DSPS repeates is parsed correctly
+    """
+    bud_obj = TotalDspsRepeatsBud()
+    assert bud_obj.stem_name == BudName.num_dsps_repeats.value
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
 
-    petal = list(bud.petals)
-    assert len(petal) == 1
-    assert petal[0].value == 2
+    assert bud_obj.bud.value == 2
 
 
 def test_dsps_flower(basic_header_objs):
@@ -592,17 +806,14 @@ def test_average_cadence_bud(basic_header_objs):
     When: Ingesting with the AverageCadenceBud
     Then: The correct values are returned
     """
-    bud = AverageCadenceBud()
-    assert bud.stem_name == BudName.average_cadence.value
+    bud_obj = AverageCadenceBud()
+    assert bud_obj.stem_name == BudName.average_cadence.value
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
-
-    petal = list(bud.petals)
-    assert len(petal) == 1
+        bud_obj.update(key, fo)
 
     # Because there are 3 observe frames in `basic_header_objs` spaced 1, and 2 seconds apart.
-    assert petal[0].value == 1.5
+    assert bud_obj.bud.value == 1.5
 
 
 def test_max_cadence_bud(basic_header_objs):
@@ -611,17 +822,14 @@ def test_max_cadence_bud(basic_header_objs):
     When: Ingesting with the MaxCadenceBud
     Then: The correct values are returned
     """
-    bud = MaximumCadenceBud()
-    assert bud.stem_name == BudName.maximum_cadence.value
+    bud_obj = MaximumCadenceBud()
+    assert bud_obj.stem_name == BudName.maximum_cadence.value
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
-
-    petal = list(bud.petals)
-    assert len(petal) == 1
+        bud_obj.update(key, fo)
 
     # Because there are 3 observe frames in `basic_header_objs` spaced 1, and 2 seconds apart.
-    assert petal[0].value == 2
+    assert bud_obj.bud.value == 2
 
 
 def test_minimum_cadence_bud(basic_header_objs):
@@ -630,17 +838,14 @@ def test_minimum_cadence_bud(basic_header_objs):
     When: Ingesting with the MinimumCadenceBud
     Then: The correct values are returned
     """
-    bud = MinimumCadenceBud()
-    assert bud.stem_name == BudName.minimum_cadence.value
+    bud_obj = MinimumCadenceBud()
+    assert bud_obj.stem_name == BudName.minimum_cadence.value
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
-
-    petal = list(bud.petals)
-    assert len(petal) == 1
+        bud_obj.update(key, fo)
 
     # Because there are 3 observe frames in `basic_header_objs` spaced 1, and 2 seconds apart.
-    assert petal[0].value == 1
+    assert bud_obj.bud.value == 1
 
 
 def test_variance_cadence_bud(basic_header_objs):
@@ -649,17 +854,29 @@ def test_variance_cadence_bud(basic_header_objs):
     When: Ingesting with the VarianceCadenceBud
     Then: The correct values are returned
     """
-    bud = VarianceCadenceBud()
-    assert bud.stem_name == BudName.variance_cadence.value
+    bud_obj = VarianceCadenceBud()
+    assert bud_obj.stem_name == BudName.variance_cadence.value
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
-
-    petal = list(bud.petals)
-    assert len(petal) == 1
+        bud_obj.update(key, fo)
 
     # Because there are 3 observe frames in `basic_header_objs` spaced 1, and 2 seconds apart.
-    assert petal[0].value == 0.25
+    assert bud_obj.bud.value == 0.25
+
+
+def test_task_date_begin_bud(basic_header_objs):
+    """
+    Given: A set of filepaths and associated headers with time_obs metadata keys
+    When: Ingesting with the TaskDateBeginBud
+    Then: The correct value is returned
+    """
+    bud_obj = TaskDateBeginBud(constant_name=BudName.dark_date_begin, ip_task_types=TaskName.dark)
+    assert bud_obj.stem_name == BudName.dark_date_begin.value
+    for fo in basic_header_objs:
+        key = fo.name
+        bud_obj.update(key, fo)
+
+    assert bud_obj.bud.value == "2022-06-17T22:00:02.000000"
 
 
 def test_observe_wavelength_bud(basic_header_objs):
@@ -668,15 +885,13 @@ def test_observe_wavelength_bud(basic_header_objs):
     When: Ingesting the headers with the ObserveWavelengthBud
     Then: The petal contains the wavelength header value of the observe frames
     """
-    bud = ObserveWavelengthBud()
-    assert bud.stem_name == BudName.wavelength.value
+    bud_obj = ObserveWavelengthBud()
+    assert bud_obj.stem_name == BudName.wavelength.value
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
 
-    petal = list(bud.petals)
-    assert len(petal) == 1
-    assert petal[0].value == 666.0
+    assert bud_obj.bud.value == 666.0
 
 
 def test_near_bud(basic_header_objs):
@@ -685,19 +900,17 @@ def test_near_bud(basic_header_objs):
     When: Ingesting headers with a NearBud and asking for the value
     Then: The Bud's value is the average of the header values
     """
-    bud = NearFloatBud(
+    bud_obj = NearFloatBud(
         constant_name="near",
         metadata_key="near_thing",
         tolerance=0.5,
     )
-    assert bud.stem_name == "near"
+    assert bud_obj.stem_name == "near"
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
 
-    petal = list(bud.petals)
-    assert len(petal) == 1
-    assert petal[0].value == 1.23
+    assert bud_obj.bud.value == 1.23
 
 
 def test_task_near_bud(basic_header_objs):
@@ -706,17 +919,53 @@ def test_task_near_bud(basic_header_objs):
     When: Ingesting headers with a TaskNearBud and asking for the value
     Then: The bud's value is the average of the header values of that task type
     """
-    bud = TaskNearFloatBud(
-        constant_name="near", metadata_key="near_thing", ip_task_type="observe", tolerance=0.5
+    bud_obj = TaskNearFloatBud(
+        constant_name="near", metadata_key="near_thing", ip_task_types="observe", tolerance=0.5
     )
-    assert bud.stem_name == "near"
+    assert bud_obj.stem_name == "near"
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
+
+    assert round(bud_obj.bud.value, 3) == 1.227
+
+
+def test_multi_task_near_bud():
+    """
+    Given: A set of headers where multiple, but not all, task types have the same values
+    When: Ingesting the headers with a `TaskNearBud`
+    Then: When multiple tasks have the same value the correct value is returned. When a task has a different value, an
+      Error is raised.
+    """
+    header_dicts = [
+        {"DKIST004": "observe", "near": 3.2},
+        {"DKIST004": "dark", "near": 3.11},
+        {"DKIST004": "solar", "near": 1e3},
+    ]
+    header_objs = [FitsReader.from_header(h, f"{i}") for i, h in enumerate(header_dicts)]
+
+    good_bud_obj = TaskNearFloatBud(
+        constant_name="near",
+        metadata_key="near_thing",
+        ip_task_types=["observe", "dark"],
+        tolerance=0.1,
+    )
+    for fo in header_objs:
+        good_bud_obj.update(fo.name, fo)
+
+    assert round(good_bud_obj.bud.value, 0) == 3.0
+
+    bad_bud_obj = TaskNearFloatBud(
+        constant_name="near",
+        metadata_key="near_thing",
+        ip_task_types=["observe", "solar"],
+        tolerance=0.1,
+    )
+    for fo in header_objs:
+        bad_bud_obj.update(fo.name, fo)
 
-    petal = list(bud.petals)
-    assert len(petal) == 1
-    assert round(petal[0].value, 3) == 1.227
+    with pytest.raises(ValueError, match="near values are not close enough"):
+        _ = bad_bud_obj.bud
 
 
 def test_near_bud_not_near_inputs(bad_header_objs):
@@ -725,18 +974,112 @@ def test_near_bud_not_near_inputs(bad_header_objs):
     When: Ingesting headers with a NearBud and asking for the value
     Then: An error is raised
     """
-    bud = NearFloatBud(
+    bud_obj = NearFloatBud(
         constant_name="near",
         metadata_key="near_thing",
         tolerance=0.5,
     )
-    assert bud.stem_name == "near"
+    assert bud_obj.stem_name == "near"
     for fo in bad_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
 
     with pytest.raises(ValueError):
-        assert next(bud.petals)
+        _ = bud_obj.bud
+
+
+def test_retarder_name_bud(basic_header_objs, task_with_polcal_header_objs, retarder_name):
+    """
+    Given: A set of headers with two values for LVL1STAT: "clear" and another name
+    When: Ingesting the headers with RetarderNameBud and asking for the value
+    Then: The retarder name is returned
+    """
+    bud_obj = RetarderNameBud()
+    input_objects = chain(basic_header_objs, task_with_polcal_header_objs)
+    for fo in input_objects:
+        key = fo.name
+        bud_obj.update(key, fo)
+
+    assert bud_obj.bud.value == retarder_name
+
+
+def test_retarder_name_bud_error(bad_polcal_header_objs):
+    """
+    Given: A set of headers with "clear" and two other values for LVL1STAT
+    When: Ingesting the headers with RetarderNameBud and asking for the value
+    Then: An error is raised
+    """
+    bud_obj = RetarderNameBud()
+    for fo in bad_polcal_header_objs:
+        key = fo.name
+        bud_obj.update(key, fo)
+
+    # Crazy regex to handle non-deterministic order of sets.
+    # https://regex101.com/r/zh9iG6/1
+    with pytest.raises(
+        ValueError,
+        match=r"Multiple RETARDER_NAME values found! Values: {'RET(1)?(?(1)|2)', 'RET(?(1)2|1)'}",
+    ):
+        _ = bud_obj.bud
+
+
+def test_task_average_bud(basic_header_objs):
+    """
+    Given: A set of headers with a differently valued header key
+    When: Ingesting headers with an TaskAverageBud and asking for the value
+    Then: The bud's value is the average of the header values of that task type
+    """
+    bud_obj = TaskAverageBud(
+        constant_name="average", metadata_key="near_thing", ip_task_types="observe"
+    )
+    assert bud_obj.stem_name == "average"
+    for fo in basic_header_objs:
+        key = fo.name
+        bud_obj.update(key, fo)
+
+    assert round(bud_obj.bud.value, 3) == 1.227
+
+
+def test_time_lookup_bud(basic_header_objs):
+    """
+    Given: A set of headers with two differently valued header keys
+    When: Ingesting headers with a TimeLookupBud and asking for the value
+    Then: The bud's value is a dictionary of one key to sets of the other key as nested tuples
+    """
+    bud = TimeLookupBud(
+        constant_name="lookup",
+        key_metadata_key=FitsReaderMetadataKey.fpa_exposure_time_ms,
+        value_metadata_key=FitsReaderMetadataKey.num_raw_frames_per_fpa,
+    )
+    assert bud.stem_name == "lookup"
+    for fo in basic_header_objs:
+        key = fo.name
+        bud.update(key, fo)
+
+    assert type(bud.mapping) == collections.defaultdict
+    assert bud.mapping == {0.0013: {3}, 12.345: {1}, 100.0: {4, 5}}
+    assert bud.bud.value == {0.0013: [3], 12.345: [1], 100.0: [4, 5]}
+
+
+def test_task_time_lookup_bud(basic_header_objs):
+    """
+    Given: A set of headers with two differently valued header keys
+    When: Ingesting headers with a TaskTimeLookupBud and asking for the value
+    Then: The bud's value is a dictionary of one key to sets of the other key as nested tuples
+    """
+    bud = TaskTimeLookupBud(
+        constant_name="task_lookup",
+        key_metadata_key=FitsReaderMetadataKey.fpa_exposure_time_ms,
+        value_metadata_key=FitsReaderMetadataKey.num_raw_frames_per_fpa,
+        ip_task_types="dark",
+    )
+    assert bud.stem_name == "task_lookup"
+    for fo in basic_header_objs:
+        key = fo.name
+        bud.update(key, fo)
+
+    assert bud.mapping == {12.345: {1}}
+    assert bud.bud.value == {12.345: [1]}
 
 
-# TODO: test new stems that have been added to parse_l0_input_data
+# TODO: test new stem types that have been added to parse_l0_input_data