dkist-processing-common 10.9.0__py3-none-any.whl → 11.0.0rc1__py3-none-any.whl

dkist_processing_common/tests/test_assemble_quality.py

@@ -220,6 +220,17 @@ def quality_metrics(dataframe_json) -> list[Metric]:
             {"name": "hist 3", "value": 9.35, "warnings": "warning for historical metric 3"},
             ["QUALITY_HISTORICAL"],
         ),
+        Metric(
+            {
+                "input_wavelength_nm": [1001.0, 1002.0, 1003.0, 1004.0],
+                "input_spectrum": [1.0, 1.0, 0.5, 1.0],
+                "best_fit_wavelength_nm": [1001.5, 1002.6, 1003.7, 1004.8],
+                "best_fit_atlas": [1.0, 1.0, 0.4, 1.0],
+                "normalized_residuals": [0.0, 0.0, 0.1, 0.0],
+                "weights": None,
+            },
+            ["QUALITY_WAVECAL_FIT"],
+        ),
     ]
     return metrics
 
@@ -247,6 +258,20 @@ def plot_data_expected() -> Callable[[str], bool]:
     return expected
 
 
+@pytest.fixture()
+def vertical_multi_pane_plot_data_expected() -> Callable[[str], bool]:
+    """
+    Tightly coupled with quality_metrics fixture and resultant report metric name
+    """
+    # names where vertical_multi_pane_plot_data is expected to be populated
+    names = {"Wavelength Calibration Results"}
+
+    def expected(name: str) -> bool:
+        return name in names
+
+    return expected
+
+
 @pytest.fixture()
 def table_data_expected() -> Callable[[str], bool]:
     """
@@ -426,6 +451,7 @@ def test_assemble_quality_data(
     assemble_quality_data_task,
     recipe_run_id,
     plot_data_expected,
+    vertical_multi_pane_plot_data_expected,
     table_data_expected,
     modmat_data_expected,
     histogram_data_expected,
@@ -447,14 +473,17 @@ def test_assemble_quality_data(
     quality_data = list(
         chain.from_iterable(task.read(tags=Tag.quality_data(), decoder=json_decoder))
     )
-    # With polcal, this would be 19, but the polcal metrics are not included with this task
-    assert len(quality_data) == 15
+    # With polcal, this would be 20, but the polcal metrics are not included with this task
+    assert len(quality_data) == 16
     for metric_data in quality_data:
         rm: ReportMetric = ReportMetric.from_dict(metric_data)
         assert isinstance(rm.name, str)
         assert isinstance(rm.description, str)
         if plot_data_expected(rm.name):
             assert rm.plot_data
+        if vertical_multi_pane_plot_data_expected(rm.name):
+            # TODO: Update this once `dkist-quality` knows about vertical multi-pane metrics
+            assert True
         if table_data_expected(rm.name):
             assert rm.table_data
         if modmat_data_expected(rm.name):
@@ -496,8 +525,8 @@ def test_assemble_quality_data_for_polcal(
     quality_data = list(
         chain.from_iterable(task.read(tags=Tag.quality_data(), decoder=json_decoder))
     )
-    # this is 19 with polcal
-    assert len(quality_data) == 19
+    # this is 20 with polcal
+    assert len(quality_data) == 20
     for metric_data in quality_data:
         rm: ReportMetric = ReportMetric.from_dict(metric_data)
         assert isinstance(rm.name, str)

dkist_processing_common/tests/test_dkist_location.py

@@ -0,0 +1,15 @@
+import pytest
+from astropy.coordinates import EarthLocation
+
+from dkist_processing_common.models.dkist_location import location_of_dkist
+
+
+@pytest.mark.flaky(max_reruns=10)
+def test_location_of_dkist():
+    """
+    Given: function for retrieving the dkist location on earth
+    When: Call function
+    Then: result is the same as what is in the astropy online database
+    """
+    itrs = location_of_dkist
+    assert itrs == EarthLocation.of_site("dkist")

dkist_processing_common/tests/test_quality_mixin.py

@@ -3,13 +3,21 @@ import json
 from io import StringIO
 from typing import Any
 
+import astropy.units as u
 import numpy as np
 import pandas
 import pytest
+from lmfit.minimizer import MinimizerResult
+from pydantic import ValidationError
+from solar_wavelength_calibration.fitter.wavelength_fitter import FitResult
+from solar_wavelength_calibration.fitter.wavelength_fitter import WavelengthParameters
 
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.json import json_encoder
 from dkist_processing_common.codecs.quality import QualityValueEncoder
+from dkist_processing_common.models.metric_code import MetricCode
+from dkist_processing_common.models.quality import Plot2D
+from dkist_processing_common.models.quality import VerticalMultiPanePlot2D
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks import WorkflowTaskBase
 from dkist_processing_common.tasks.mixin.quality import QualityMixin
@@ -21,7 +29,7 @@ class Task(WorkflowTaskBase, QualityMixin):
 
 
 @pytest.fixture
-def quality_task(tmp_path, recipe_run_id):
+def quality_task(tmp_path, recipe_run_id) -> Task:
     with Task(
         recipe_run_id=recipe_run_id,
         workflow_name="workflow_name",
@@ -106,6 +114,7 @@ def test_create_2d_plot_with_datetime_metric(quality_task):
         "facet",
         "statement",
         "plot_data",
+        "vertical_multi_pane_plot_data",
         "histogram_data",
         "table_data",
         "modmat_data",
@@ -1185,6 +1194,170 @@ def test_avg_noise_nan_values(quality_task, array_shape):
     assert not np.isnan(result)
 
 
+@pytest.fixture(scope="session")
+def wavecal_input_wavelength() -> u.Quantity:
+    return np.arange(100) * u.nm
+
+
+@pytest.fixture(scope="session")
+def wavecal_input_spectrum(wavecal_input_wavelength) -> np.ndarray:
+    return (wavecal_input_wavelength.value - wavecal_input_wavelength.size // 2) ** 2 + 10.0
+
+
+@pytest.fixture(scope="session")
+def wavecal_weights(wavecal_input_wavelength) -> np.ndarray:
+    return np.arange(wavecal_input_wavelength.size)
+
+
+@pytest.fixture(scope="session")
+def wavecal_fit_result(wavecal_input_wavelength) -> FitResult:
+    wavelength_params = WavelengthParameters(
+        crpix=1, crval=10.0, dispersion=1, grating_constant=1, order=1, incident_light_angle=0
+    )
+    minimizer_result = MinimizerResult(residual=np.random.random(wavecal_input_wavelength.size))
+    return FitResult(wavelength_parameters=wavelength_params, minimizer_result=minimizer_result)
+
+
+@pytest.mark.parametrize(
+    "use_weights",
+    [pytest.param(True, id="custom_weights"), pytest.param(False, id="default_weights")],
+)
+def test_wavecal_store_results(
+    quality_task,
+    wavecal_input_wavelength,
+    wavecal_input_spectrum,
+    wavecal_fit_result,
+    wavecal_weights,
+    use_weights,
+):
+    """
+    Given: A task with the QualityMixin and the results of a wavecal fit
+    When: Storing the wavecal metric
+    Then: The correct metric json files are written and their contents contain the correct types of data
+    """
+    quality_task.quality_store_wavecal_results(
+        input_wavelength=wavecal_input_wavelength,
+        input_spectrum=wavecal_input_spectrum,
+        fit_result=wavecal_fit_result,
+        weights=wavecal_weights if use_weights else None,
+    )
+
+    wavecal_quality_files = list(quality_task.read(tags=[Tag.quality(MetricCode.wavecal_fit)]))
+    assert len(wavecal_quality_files) == 1
+    with open(wavecal_quality_files[0], "r") as f:
+        results_dict = json.load(f)
+        assert sorted(results_dict.keys()) == sorted(
+            [
+                "input_wavelength_nm",
+                "input_spectrum",
+                "best_fit_wavelength_nm",
+                "best_fit_atlas",
+                "normalized_residuals",
+                "weights",
+            ]
+        )
+        for k, v in results_dict.items():
+            if k != "weights" or use_weights:
+                assert isinstance(v, list)
+                assert len(v) == len(results_dict["input_wavelength_nm"])
+        if not use_weights:
+            assert results_dict["weights"] is None
+
+
+@pytest.fixture(
+    scope="session",
+    params=[pytest.param([0, 1.0, 0.8, 0.0], id="weights"), pytest.param(None, id="no_weights")],
+)
+def wavecal_data_json(request) -> dict:
+    weights = request.param
+    return {
+        "input_wavelength_nm": [1001.0, 1002.0, 1003.0, 1004.0],
+        "input_spectrum": [1.0, 1.0, 0.5, 1.0],
+        "best_fit_wavelength_nm": [1001.5, 1002.6, 1003.7, 1004.8],
+        "best_fit_atlas": [1.0, 1.0, 0.4, 1.0],
+        "normalized_residuals": [0.0, 0.0, 0.1, 0.0],
+        "weights": weights,
+    }
+
+
+def test_build_wavecal_results(quality_task, wavecal_data_json):
+    """
+    Given: A task with the QualityMixin
+    When: Building the wavecal results quality metric
+    Then: The correct metric model is returned
+    """
+    weights_included = wavecal_data_json["weights"] is not None
+    quality_task.write(
+        data=wavecal_data_json,
+        tags=[Tag.quality(MetricCode.wavecal_fit)],
+        encoder=json_encoder,
+        allow_nan=False,
+        cls=QualityValueEncoder,
+    )
+    metric = quality_task.quality_build_wavecal_results()
+
+    assert metric["name"] == "Wavelength Calibration Results"
+    assert metric["description"] == (
+        "These plots show the wavelength solution computed based on fits to a Solar FTS atlas. "
+        "The top plot shows the input and best-fit spectra along with the best-fit atlas, which is "
+        "a combination of Solar and Telluric spectra. The bottom plot shows the fir residuals."
+    )
+    assert metric["metric_code"] == MetricCode.wavecal_fit.value
+    assert metric["facet"] is None
+    assert metric["statement"] is None
+    assert metric["plot_data"] is None
+    assert metric["histogram_data"] is None
+    assert metric["table_data"] is None
+    assert metric["modmat_data"] is None
+    assert metric["efficiency_data"] is None
+    assert metric["raincloud_data"] is None
+    assert metric["warnings"] is None
+
+    multi_plot_data = metric["vertical_multi_pane_plot_data"]
+    assert multi_plot_data["match_x_axes"] is True
+    assert multi_plot_data["no_gap"] is True
+    assert (
+        multi_plot_data["top_to_bottom_height_ratios"] == [1.5, 1, 1]
+        if weights_included
+        else [1.5, 1]
+    )
+    plot_list = multi_plot_data["top_to_bottom_plot_list"]
+    assert isinstance(plot_list, list)
+    assert len(plot_list) == 3 if weights_included else 3
+
+    fit_plot = plot_list[0]
+    assert fit_plot["sort_series"] is False
+    assert fit_plot["xlabel"] == "Wavelength [nm]"
+    assert fit_plot["ylabel"] == "Signal"
+    assert fit_plot["series_data"] == {
+        "Input Spectrum": [[1001.0, 1002.0, 1003.0, 1004.0], [1.0, 1.0, 0.5, 1.0]],
+        "Best Fit Observations": [[1001.5, 1002.6, 1003.7, 1004.8], [1.0, 1.0, 0.5, 1.0]],
+        "Best Fit Atlas": [[1001.5, 1002.6, 1003.7, 1004.8], [1.0, 1.0, 0.4, 1.0]],
+    }
+    assert fit_plot["plot_kwargs"] == {
+        "Input Spectrum": {"ls": "-", "alpha": 0.4, "ms": 0},
+        "Best Fit Observations": {"ls": "-", "lw": 4, "alpha": 0.8, "ms": 0},
+        "Best Fit Atlas": {"color": "k", "ls": "-", "ms": 0},
+    }
+
+    residuals_plot = plot_list[1]
+    assert residuals_plot["xlabel"] == "Wavelength [nm]"
+    assert residuals_plot["ylabel"] == r"$\frac{\mathrm{Obs - Atlas}}{\mathrm{Obs}}$"
+    assert residuals_plot["series_data"] == {
+        "Residuals": [[1001.5, 1002.6, 1003.7, 1004.8], [0.0, 0.0, 0.1, 0.0]]
+    }
+    assert residuals_plot["plot_kwargs"] == {"Residuals": {"ls": "-", "color": "k", "ms": 0}}
+
+    if weights_included:
+        weights_plot = plot_list[2]
+        assert weights_plot["xlabel"] == "Wavelength [nm]"
+        assert weights_plot["ylabel"] == "Fit Weights"
+        assert weights_plot["series_data"] == {
+            "Weights": [[1001.5, 1002.6, 1003.7, 1004.8], [0.0, 1.0, 0.8, 0.0]]
+        }
+        assert weights_plot["plot_kwargs"] == {"Weights": {"ls": "-", "color": "k", "ms": 0}}
+
+
 @pytest.mark.parametrize(
     "bin_strs, sampled_bins, expected_bin_str, expected_sample_str",
     [
@@ -1255,3 +1428,33 @@ def test_format_facet(label: str | Any, expected_result: str):
     Then: the label is properly formatted
     """
     assert QualityMixin._format_facet(label) == expected_result
+
+
+def test_validate_vertical_multi_pane_plot_model():
+    """
+    Given: A `VerticalMultiPanePlot2D` model and some `Plot2D` models
+    When: Instantiating the `VerticalMultiPanePlot2D` with various parameters
+    Then: The `top_to_bottom_plot_ratios` property is correctly populated
+    """
+    plot2d = Plot2D(xlabel="X", ylabel="Y", series_data={"Foo": [[1.0], [2.0]]})
+
+    # Test given ratios valid case
+    _ = VerticalMultiPanePlot2D(
+        top_to_bottom_plot_list=[plot2d, plot2d], top_to_bottom_height_ratios=[1.0, 2.0]
+    )
+
+    # Test None ratios
+    vertical_plots = VerticalMultiPanePlot2D(
+        top_to_bottom_plot_list=[plot2d, plot2d], top_to_bottom_height_ratios=None
+    )
+    assert vertical_plots.top_to_bottom_height_ratios == [1.0, 1.0]
+
+    # Test invalid case
+    with pytest.raises(
+        ValidationError,
+        match="The number of items in `top_to_bottom_height_ratios` list \(3\) is not "
+        "the same as the number of plots \(2\)",
+    ):
+        _ = VerticalMultiPanePlot2D(
+            top_to_bottom_plot_list=[plot2d, plot2d], top_to_bottom_height_ratios=[1.0, 2.0, 3.0]
+        )

dkist_processing_common/tests/test_stems.py

@@ -32,6 +32,7 @@ from dkist_processing_common.parsers.time import ObsIpStartTimeBud
 from dkist_processing_common.parsers.time import ReadoutExpTimeFlower
 from dkist_processing_common.parsers.time import TaskExposureTimesBud
 from dkist_processing_common.parsers.time import TaskReadoutExpTimesBud
+from dkist_processing_common.parsers.time import TaskTimeBudBase
 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
@@ -61,6 +62,7 @@ class FitsReader(FitsAccessBase):
         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.roundable_time: float = self.header.get("RTIME", 0.0)
 
 
 @pytest.fixture()
@@ -120,6 +122,7 @@ def basic_header_objs():
                 "DKIST011": "1903-01-01T12:00.000",
                 "LINEWAV": 0.0,
                 "GOSRET": "wrong",
+                "RTIME": 2.3400000009999,
             }
         ),
         "thing3": fits.header.Header(
@@ -139,6 +142,26 @@ def basic_header_objs():
                 "DKIST011": "2023-09-28T10:23.000",
                 "LINEWAV": 666.0,
                 "GOSRET": "clear",
+            },
+        ),
+        "thing4": fits.header.Header(
+            {
+                "DKIST004": "gain",
+                "ID___013": "proposal_id_1",
+                "id_key": 0,
+                "constant": 6.28,
+                "near": 1.23,
+                "ID___012": "experiment_id_1",
+                "XPOSURE": 100.0,
+                "TEXPOSUR": 11.0,
+                "NSUMEXP": 4,
+                "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,
             }
         ),
     }
@@ -203,6 +226,30 @@ 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())
 
@@ -257,14 +304,21 @@ def test_unique_bud_non_unique_inputs(bad_header_objs):
         assert next(bud.petals)
 
 
-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"
+        constant_name="proposal", metadata_key="proposal_id", ip_task_types=ip_task_type
     )
     assert bud.stem_name == "proposal"
     for fo in basic_header_objs:
@@ -276,14 +330,21 @@ def test_task_unique_bud(basic_header_objs):
     assert petal[0].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:
@@ -291,7 +352,7 @@ def test_task_unique_bud_non_unique_inputs(bad_header_objs):
         bud.update(key, fo)
 
     with pytest.raises(ValueError):
-        assert next(bud.petals)
+        list(bud.petals)
 
 
 def test_single_value_single_key_flower(basic_header_objs):
@@ -309,13 +370,40 @@ 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", (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_time_base_bud(basic_header_objs, ip_task_type, expected_value):
+    """
+    Given: A set of headers with a value that needs to be rounded
+    When: Ingesting headers with a `TaskTimeBudBase` bud and asking for the value
+    Then: The bud's value is the header constant value
+    """
+    bud = TaskTimeBudBase(
+        stem_name="rounded_time", metadata_key="roundable_time", ip_task_types=ip_task_type
+    )
+    assert bud.stem_name == "rounded_time"
+    for fo in basic_header_objs:
+        key = fo.name
+        bud.update(key, fo)
+
+    petal = list(bud.petals)
+    assert len(petal) == 1
+    assert petal[0].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
@@ -444,7 +532,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):
@@ -466,7 +554,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):
@@ -534,8 +622,8 @@ 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")
+    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
     for fo in basic_header_objs:
         key = fo.name
@@ -559,8 +647,8 @@ 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")
+    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
     for fo in basic_header_objs:
         key = fo.name
@@ -731,7 +819,7 @@ def test_task_near_bud(basic_header_objs):
     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
+        constant_name="near", metadata_key="near_thing", ip_task_types="observe", tolerance=0.5
     )
     assert bud.stem_name == "near"
     for fo in basic_header_objs:
@@ -743,6 +831,46 @@ def test_task_near_bud(basic_header_objs):
     assert round(petal[0].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)]
+
+    bud = 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)
+
+    petal = list(bud.petals)
+    assert len(petal) == 1
+    assert round(petal[0].value, 0) == 3.0
+
+    bad_bud = 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)
+
+    with pytest.raises(ValueError, match="near values are not close enough"):
+        list(bad_bud.petals)
+
+
 def test_near_bud_not_near_inputs(bad_header_objs):
     """
     Given: A set of headers with a header key that is expected to be in a given range but is not

dkist_processing_common/tests/test_write_l1.py

@@ -657,18 +657,6 @@ def test_spectral_line_keys(write_l1_task, mocker):
         assert header["SPECLN03"]
 
 
-@pytest.mark.flaky(max_reruns=10)
-def test_location_of_dkist(write_l1_task):
-    """
-    Given: function for retrieving the dkist location on earth
-    When: Call function
-    Then: result is the same as what is in the astropy online database
-    """
-    task, _, _ = write_l1_task
-    itrs = task.location_of_dkist
-    assert itrs == EarthLocation.of_site("dkist")
-
-
 def test_check_r0_ao_lock(write_l1_task_no_data):
     """
     :Given: a header

{dkist_processing_common-10.9.0.dist-info → dkist_processing_common-11.0.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-common
-Version: 10.9.0
+Version: 11.0.0rc1
 Summary: Common task classes used by the DKIST science data processing pipelines
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause
@@ -21,6 +21,7 @@ Requires-Dist: dkist-processing-core==5.1.1
 Requires-Dist: dkist-processing-pac<4.0,>=3.1
 Requires-Dist: dkist-service-configuration<3.0,>=2.0.2
 Requires-Dist: dkist-spectral-lines<4.0,>=3.0.0
+Requires-Dist: solar-wavelength-calibration<2.0,>=1.0
 Requires-Dist: globus-sdk>=3.12.0
 Requires-Dist: gqlclient[pydantic]==1.2.3
 Requires-Dist: sqids==0.5.1
@@ -60,7 +61,7 @@ Requires-Dist: dkist-inventory<2.0,>=1.6.0; extra == "inventory"
 Provides-Extra: asdf
 Requires-Dist: dkist-inventory[asdf]<2.0,>=1.6.0; extra == "asdf"
 Provides-Extra: quality
-Requires-Dist: dkist-quality<2.0,>=1.2.1; extra == "quality"
+Requires-Dist: dkist-quality<2.0,>=1.3.0rc1; extra == "quality"
 
 dkist-processing-common
 =======================