dkist-processing-common 12.0.0rc5__py3-none-any.whl → 12.2.0__py3-none-any.whl

dkist_processing_common/tests/test_stems.py

@@ -323,18 +323,16 @@ def test_unique_bud(basic_header_objs):
     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):
@@ -343,17 +341,17 @@ 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
 
 
 @pytest.mark.parametrize(
@@ -369,17 +367,15 @@ def test_task_unique_bud(basic_header_objs, ip_task_type):
     When: Ingesting headers with a TaskUniqueBud and asking for the value
     Then: The bud's value is the header constant value
     """
-    bud = TaskUniqueBud(
+    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"
 
 
 @pytest.mark.parametrize(
@@ -403,8 +399,8 @@ def test_task_unique_bud_non_unique_inputs(bad_header_objs, ip_task_type):
         key = fo.name
         bud.update(key, fo)
 
-    with pytest.raises(ValueError):
-        list(bud.petals)
+    with pytest.raises(ValueError, match="Multiple constant values found! Values:"):
+        _ = bud.bud
 
 
 def test_single_value_single_key_flower(basic_header_objs):
@@ -447,18 +443,17 @@ def test_task_datetime_base_bud(basic_header_objs, ip_task_type, expected_value)
     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 = TaskDatetimeBudBase(
+    bud_obj = TaskDatetimeBudBase(
         stem_name="datetimes",
         metadata_key=FitsReaderMetadataKey.time_obs,
         ip_task_types=ip_task_type,
     )
-    assert bud.stem_name == "datetimes"
+    assert bud_obj.stem_name == "datetimes"
     for fo in basic_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
 
-    petal = list(bud.petals)
-    assert petal[0].value == expected_value
+    assert bud_obj.bud.value == expected_value
 
 
 @pytest.mark.parametrize(
@@ -475,17 +470,15 @@ def test_task_round_time_base_bud(basic_header_objs, ip_task_type, expected_valu
     When: Ingesting headers with a `TaskRoundTimeBudBase` bud and asking for the value
     Then: The bud's value is the header constant value
     """
-    bud = TaskRoundTimeBudBase(
+    bud_obj = TaskRoundTimeBudBase(
         stem_name="rounded_time", metadata_key="roundable_time", ip_task_types=ip_task_type
     )
-    assert bud.stem_name == "rounded_time"
+    assert bud_obj.stem_name == "rounded_time"
     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 == expected_value
+    assert bud_obj.bud.value == expected_value
 
 
 def test_cs_step_flower(grouped_cal_sequence_headers, non_polcal_headers, max_cs_step_time_sec):
@@ -516,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):
@@ -535,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):
@@ -552,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):
@@ -569,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):
@@ -586,15 +571,13 @@ 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):
@@ -603,19 +586,17 @@ def test_task_contributing_ids_bud(basic_header_objs):
     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 = TaskContributingIdsBud(
+    bud_obj = TaskContributingIdsBud(
         constant_name=BudName.experiment_id,
         metadata_key=MetadataKey.experiment_id,
         ip_task_types=TaskName.dark,
     )
-    assert bud.stem_name == BudName.experiment_id.value
+    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 sorted(list(petal[0].value)) == ["experiment_id_2"]
+    assert sorted(list(bud_obj.bud.value)) == ["experiment_id_2"]
 
 
 def test_task_contributing_observing_program_execution_ids_bud(basic_header_objs):
@@ -624,18 +605,16 @@ def test_task_contributing_observing_program_execution_ids_bud(basic_header_objs
     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 = TaskContributingObservingProgramExecutionIdsBud(
+    bud_obj = TaskContributingObservingProgramExecutionIdsBud(
         constant_name="NOT_A_REAL_BUD",
         ip_task_types=TaskName.observe,
     )
-    assert bud.stem_name == "NOT_A_REAL_BUD"
+    assert bud_obj.stem_name == "NOT_A_REAL_BUD"
     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)) == [
+    assert sorted(list(bud_obj.bud.value)) == [
         "observing_program_execution_id_1",
         "observing_program_execution_id_2",
     ]
@@ -733,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):
@@ -750,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_types="DARK")
-    obs_bud = TaskExposureTimesBud(stem_name="obs_exp_times", ip_task_types="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):
@@ -775,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_types="DARK")
-    obs_bud = TaskReadoutExpTimesBud(stem_name="obs_exp_times", ip_task_types="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):
@@ -832,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):
@@ -851,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):
@@ -870,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):
@@ -889,17 +854,14 @@ 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):
@@ -908,15 +870,13 @@ def test_task_date_begin_bud(basic_header_objs):
     When: Ingesting with the TaskDateBeginBud
     Then: The correct value is returned
     """
-    bud = TaskDateBeginBud(constant_name=BudName.dark_date_begin, ip_task_types=TaskName.dark)
-    assert bud.stem_name == BudName.dark_date_begin.value
+    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.update(key, fo)
+        bud_obj.update(key, fo)
 
-    petal = list(bud.petals)
-    assert len(petal) == 1
-    assert petal[0].value == "2022-06-17T22:00:02.000000"
+    assert bud_obj.bud.value == "2022-06-17T22:00:02.000000"
 
 
 def test_observe_wavelength_bud(basic_header_objs):
@@ -925,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):
@@ -942,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):
@@ -963,17 +919,15 @@ 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(
+    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)
 
-    petal = list(bud.petals)
-    assert len(petal) == 1
-    assert round(petal[0].value, 3) == 1.227
+    assert round(bud_obj.bud.value, 3) == 1.227
 
 
 def test_multi_task_near_bud():
@@ -990,30 +944,28 @@ def test_multi_task_near_bud():
     ]
     header_objs = [FitsReader.from_header(h, f"{i}") for i, h in enumerate(header_dicts)]
 
-    bud = TaskNearFloatBud(
+    good_bud_obj = TaskNearFloatBud(
         constant_name="near",
         metadata_key="near_thing",
         ip_task_types=["observe", "dark"],
         tolerance=0.1,
     )
     for fo in header_objs:
-        bud.update(fo.name, fo)
+        good_bud_obj.update(fo.name, fo)
 
-    petal = list(bud.petals)
-    assert len(petal) == 1
-    assert round(petal[0].value, 0) == 3.0
+    assert round(good_bud_obj.bud.value, 0) == 3.0
 
-    bad_bud = TaskNearFloatBud(
+    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.update(fo.name, fo)
+        bad_bud_obj.update(fo.name, fo)
 
     with pytest.raises(ValueError, match="near values are not close enough"):
-        list(bad_bud.petals)
+        _ = bad_bud_obj.bud
 
 
 def test_near_bud_not_near_inputs(bad_header_objs):
@@ -1022,18 +974,18 @@ 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):
@@ -1042,13 +994,13 @@ def test_retarder_name_bud(basic_header_objs, task_with_polcal_header_objs, reta
     When: Ingesting the headers with RetarderNameBud and asking for the value
     Then: The retarder name is returned
     """
-    bud = RetarderNameBud()
+    bud_obj = RetarderNameBud()
     input_objects = chain(basic_header_objs, task_with_polcal_header_objs)
     for fo in input_objects:
         key = fo.name
-        bud.update(key, fo)
+        bud_obj.update(key, fo)
 
-    assert bud.bud.value == retarder_name
+    assert bud_obj.bud.value == retarder_name
 
 
 def test_retarder_name_bud_error(bad_polcal_header_objs):
@@ -1057,18 +1009,18 @@ def test_retarder_name_bud_error(bad_polcal_header_objs):
     When: Ingesting the headers with RetarderNameBud and asking for the value
     Then: An error is raised
     """
-    bud = RetarderNameBud()
+    bud_obj = RetarderNameBud()
     for fo in bad_polcal_header_objs:
         key = fo.name
-        bud.update(key, fo)
+        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 non-clear retarder names found. Names: {'RET(1)?(?(1)|2)', 'RET(?(1)2|1)'}",
+        match=r"Multiple RETARDER_NAME values found! Values: {'RET(1)?(?(1)|2)', 'RET(?(1)2|1)'}",
     ):
-        _ = bud.bud
+        _ = bud_obj.bud
 
 
 def test_task_average_bud(basic_header_objs):
@@ -1077,17 +1029,15 @@ def test_task_average_bud(basic_header_objs):
     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 = TaskAverageBud(
+    bud_obj = TaskAverageBud(
         constant_name="average", metadata_key="near_thing", ip_task_types="observe"
     )
-    assert bud.stem_name == "average"
+    assert bud_obj.stem_name == "average"
     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 round(petal[0].value, 3) == 1.227
+    assert round(bud_obj.bud.value, 3) == 1.227
 
 
 def test_time_lookup_bud(basic_header_objs):
@@ -1108,9 +1058,7 @@ def test_time_lookup_bud(basic_header_objs):
 
     assert type(bud.mapping) == collections.defaultdict
     assert bud.mapping == {0.0013: {3}, 12.345: {1}, 100.0: {4, 5}}
-    assert len(bud.petals) == 1
-    expected_value = ((0.0013, (3,)), (12.345, (1,)), (100.0, (4, 5)))
-    assert bud.petals[0].value == expected_value
+    assert bud.bud.value == {0.0013: [3], 12.345: [1], 100.0: [4, 5]}
 
 
 def test_task_time_lookup_bud(basic_header_objs):
@@ -1130,9 +1078,8 @@ def test_task_time_lookup_bud(basic_header_objs):
         key = fo.name
         bud.update(key, fo)
 
-    assert len(bud.petals) == 1
-    expected_value = ((12.345, (1,)),)
-    assert bud.petals[0].value == expected_value
+    assert bud.mapping == {12.345: {1}}
+    assert bud.bud.value == {12.345: [1]}
 
 
 # TODO: test new stem types that have been added to parse_l0_input_data