dkist-processing-common 10.8.1rc1__py3-none-any.whl → 10.8.3__py3-none-any.whl

dkist_processing_common/tests/test_quality_mixin.py

@@ -39,9 +39,9 @@ def quality_task(tmp_path, recipe_run_id):
 @pytest.fixture
 def plot_data():
     datetimes_a = ["2021-01-01T01:01:01", "2021-01-01T02:01:01"]
-    values_a = [3, 4]
+    values_a = [0.1, 0.2]
     datetimes_b = ["2020-01-01T01:01:01", "2020-01-01T02:01:01"]
-    values_b = [1, 2]
+    values_b = [0.15, 0.25]
     return datetimes_a, values_a, datetimes_b, values_b
 
 
@@ -198,8 +198,9 @@ def test_store_ao_status_and_fried_parameter(quality_task, ao_values):
     """
     task = quality_task
     datetimes = ["2020-01-01T01:01:01", "2020-01-01T02:01:01"]
-    fried_values = [3.0, 4.0]
-    combined_values = [[ao, r0] for ao, r0 in zip(ao_values, fried_values)]
+    fried_values = [0.1, 0.2]
+    oob_values = [25, 50]
+    combined_values = [[ao, r0, oob] for ao, r0, oob in zip(ao_values, fried_values, oob_values)]
     task.quality_store_ao_status_and_fried_parameter(datetimes=datetimes, values=combined_values)
     path = list(task.read(tags=Tag.quality("AO_STATUS")))
     assert len(path) == 1
@@ -220,10 +221,11 @@ def test_store_ao_status_and_fried_parameter(quality_task, ao_values):
 @pytest.mark.parametrize(
     "combined_values",
     [
-        pytest.param([[True, 1], [None, 2]], id="AO_some_none"),
-        pytest.param([[True, 1], [True, None]], id="Fried_some_none"),
-        pytest.param([[None, 1], [None, 2]], id="AO_all_none"),
-        pytest.param([[True, None], [True, None]], id="Fried_all_none"),
+        pytest.param([[True, 0.1, 25], [None, 0.2, 25]], id="AO_some_none"),
+        pytest.param([[True, 0.1, 25], [True, None, 25]], id="Fried_some_none"),
+        pytest.param([[None, 0.1, 25], [None, 0.2, 25]], id="AO_all_none"),
+        pytest.param([[True, None, 25], [True, None, 25]], id="Fried_all_none"),
+        pytest.param([[True, 0.1, None], [True, 0.2, None]], id="Out_of_bounds_all_none"),
     ],
 )
 def test_store_ao_status_and_fried_parameter_with_nones(quality_task, combined_values):
@@ -231,13 +233,14 @@ def test_store_ao_status_and_fried_parameter_with_nones(quality_task, combined_v
     datetimes = ["2020-01-01T01:01:01", "2020-01-01T02:01:01"]
     task.quality_store_ao_status_and_fried_parameter(datetimes=datetimes, values=combined_values)
     path = list(task.read(tags=Tag.quality("AO_STATUS")))
-    ao_values = [ao for ao, r0 in combined_values]
-    fried_values = [r0 for ao, r0 in combined_values]
+    ao_values = [ao for ao, r0, oob in combined_values]
+    fried_values = [r0 for ao, r0, oob in combined_values]
+    ao_out_of_bounds = [oob for ao, r0, oob in combined_values]
     if not all(ao is None for ao in ao_values):
         assert len(path) == 1
         with path[0].open() as f:
             data = json.load(f)
-            assert len(data) == sum(1 for ao, r0 in combined_values if ao is not None)
+            assert len(data) == sum(1 for ao, r0, oob in combined_values if ao is not None)
     else:
         assert len(path) == 0
     path = list(task.read(tags=Tag.quality("FRIED_PARAMETER")))
@@ -246,7 +249,7 @@ def test_store_ao_status_and_fried_parameter_with_nones(quality_task, combined_v
         with path[0].open() as f:
             data = json.load(f)
             assert len(data["y_values"]) == sum(
-                1 for ao, r0 in combined_values if ao is True and r0 is not None
+                1 for ao, r0, oob in combined_values if ao is True and r0 is not None
             )
     else:
         assert len(path) == 0
@@ -263,7 +266,8 @@ def test_build_ao_status(quality_task, plot_data):
     datetimes = datetimes_a + datetimes_b
     fried_values = values_a + values_b
     ao_values = [False, True, True, True]
-    combined_values = [[ao, r0] for ao, r0 in zip(ao_values, fried_values)]
+    oob_values = [25, 50, None, 50]
+    combined_values = [[ao, r0, oob] for ao, r0, oob in zip(ao_values, fried_values, oob_values)]
     task.quality_store_ao_status_and_fried_parameter(datetimes=datetimes, values=combined_values)
     metric = task.quality_build_ao_status()
     assert metric["name"] == "Adaptive Optics Status"
@@ -284,9 +288,15 @@ def test_build_fried_parameter(quality_task, plot_data):
     task = quality_task
     datetimes_a, fried_values_a, datetimes_b, fried_values_b = plot_data
     ao_values_a = [True, True]
-    combined_values_a = [[ao, r0] for ao, r0 in zip(ao_values_a, fried_values_a)]
+    oob_values_a = [25, 50]
+    combined_values_a = [
+        [ao, r0, oob] for ao, r0, oob in zip(ao_values_a, fried_values_a, oob_values_a)
+    ]
     ao_values_b = [True, True]
-    combined_values_b = [[ao, r0] for ao, r0 in zip(ao_values_b, fried_values_b)]
+    oob_values_b = [25, 50]
+    combined_values_b = [
+        [ao, r0, oob] for ao, r0, oob in zip(ao_values_b, fried_values_b, oob_values_b)
+    ]
     task.quality_store_ao_status_and_fried_parameter(
         datetimes=datetimes_a, values=combined_values_a
     )
@@ -307,14 +317,14 @@ def test_build_fried_parameter(quality_task, plot_data):
             "2021-01-01T02:01:01",
         ]
     ]
-    assert metric["plot_data"]["series_data"][""][1] == [1, 2, 3, 4]
+    assert metric["plot_data"]["series_data"][""][1] == [0.15, 0.25, 0.1, 0.2]
     assert metric["name"] == "Fried Parameter"
     assert metric["metric_code"] == "FRIED_PARAMETER"
     assert metric["facet"] is None
     assert metric["warnings"] is None
     assert (
         metric["statement"]
-        == "Average valid Fried Parameter measurements for L1 dataset: 2.5 ± 1.12 m"
+        == "Average valid Fried Parameter measurements for L1 dataset: 0.18 ± 0.06 m"
     )
 
 
@@ -340,12 +350,12 @@ def test_build_light_level(quality_task, plot_data):
             "2021-01-01T02:01:01",
         ]
     ]
-    assert metric["plot_data"]["series_data"][""][1] == [1, 2, 3, 4]
+    assert metric["plot_data"]["series_data"][""][1] == [0.15, 0.25, 0.1, 0.2]
     assert metric["name"] == "Light Level"
     assert metric["metric_code"] == "LIGHT_LEVEL"
     assert metric["facet"] is None
     assert metric["warnings"] is None
-    assert metric["statement"] == f"Average Light Level for L1 dataset: 2.5 ± 1.12 adu"
+    assert metric["statement"] == f"Average Light Level for L1 dataset: 0.18 ± 0.06 adu"
 
 
 def test_build_frame_average(quality_task, plot_data):
@@ -461,7 +471,7 @@ def test_build_noise(quality_task, plot_data):
             "2021-01-01T02:01:01",
         ]
     ]
-    assert metric["plot_data"]["series_data"]["I"][1] == [1, 2, 3, 4]
+    assert metric["plot_data"]["series_data"]["I"][1] == [0.15, 0.25, 0.1, 0.2]
     assert metric["name"] == "Noise Estimation"
     assert metric["metric_code"] == "NOISE"
     assert metric["facet"] is None
@@ -493,7 +503,7 @@ def test_build_sensitivity(quality_task, plot_data):
             "2021-01-01T02:01:01",
         ]
     ]
-    assert metric["plot_data"]["series_data"]["I"][1] == [1, 2, 3, 4]
+    assert metric["plot_data"]["series_data"]["I"][1] == [0.15, 0.25, 0.1, 0.2]
     assert metric["name"] == f"Sensitivity"
     assert metric["metric_code"] == "SENSITIVITY"
     assert metric["facet"] is None
@@ -692,7 +702,7 @@ def test_build_report(quality_task, plot_data):
     task.quality_store_task_type_counts(task_type="dark", total_frames=100, frames_not_used=7)
     task.quality_store_task_type_counts(task_type="gain", total_frames=100, frames_not_used=0)
     task.quality_store_ao_status_and_fried_parameter(
-        datetimes=datetimes, values=[[True, values[0]], [True, values[1]]]
+        datetimes=datetimes, values=[[True, values[0], values[0]], [True, values[1], values[1]]]
     )
     task.quality_store_light_level(datetimes=datetimes, values=values)
     task.quality_store_frame_average(

dkist_processing_common/tests/test_transfer_input_data.py

@@ -5,12 +5,10 @@ from pathlib import Path
 import pytest
 
 from dkist_processing_common._util.scratch import WorkflowFileSystem
-from dkist_processing_common.codecs.basemodel import basemodel_decoder
+from dkist_processing_common.codecs.json import json_decoder
 from dkist_processing_common.models.graphql import InputDatasetRecipeRunResponse
-from dkist_processing_common.models.input_dataset import InputDatasetPartDocumentList
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks.transfer_input_data import TransferL0Data
-from dkist_processing_common.tests.conftest import create_input_frames
 from dkist_processing_common.tests.conftest import create_parameter_files
 from dkist_processing_common.tests.conftest import FakeGQLClient
 
@@ -20,7 +18,7 @@ class TransferL0DataTask(TransferL0Data):
         ...
 
 
-class FakeGQLClientMissingInputDatasetCalibrationPart(FakeGQLClient):
+class FakeGQLClientMissingInputDatasetPart(FakeGQLClient):
     """Same metadata mocker with calibration input dataset part missing."""
 
     def execute_gql_query(self, **kwargs):
@@ -55,152 +53,103 @@ def transfer_l0_data_task(recipe_run_id, tmp_path, mocker):
 
 
 @pytest.fixture
-def transfer_l0_data_task_missing_calibration_part(recipe_run_id, tmp_path, mocker):
+def transfer_l0_data_task_missing_part(recipe_run_id, tmp_path, mocker):
     yield from _transfer_l0_data_task_with_client(
-        recipe_run_id, tmp_path, mocker, FakeGQLClientMissingInputDatasetCalibrationPart
+        recipe_run_id, tmp_path, mocker, FakeGQLClientMissingInputDatasetPart
     )
 
 
-@pytest.mark.parametrize(
-    "expected_doc, tag",
-    [
-        pytest.param(
-            FakeGQLClient.observe_frames_doc_object,
-            Tag.input_dataset_observe_frames(),
-            id="observe_frames",
-        ),
-        pytest.param(
-            FakeGQLClient.calibration_frames_doc_object,
-            Tag.input_dataset_calibration_frames(),
-            id="calibration_frames",
-        ),
-        pytest.param(
-            FakeGQLClient.parameters_doc_object,
-            Tag.input_dataset_parameters(),
-            id="parameters",
-        ),
-    ],
-)
-def test_download_dataset(transfer_l0_data_task, expected_doc, tag):
+def test_download_dataset(transfer_l0_data_task):
     """
     :Given: a TransferL0Data task with a valid input dataset
     :When: downloading the dataset documents from the metadata store
-    :Then: the correct documents are written to disk, along with tags for file parameters
+    :Then: the correct documents are written to disk
     """
     # Given
     task = transfer_l0_data_task
     # When
     task.download_input_dataset()
     # Then
-    doc_from_file = next(
-        task.read(tags=tag, decoder=basemodel_decoder, model=InputDatasetPartDocumentList)
+    expected_observe_doc = FakeGQLClient.observe_frames_doc_object
+    observe_doc_from_file = next(
+        task.read(tags=Tag.input_dataset_observe_frames(), decoder=json_decoder)
+    )
+    assert observe_doc_from_file == expected_observe_doc
+    expected_calibration_doc = FakeGQLClient.calibration_frames_doc_object
+    calibration_doc_from_file = next(
+        task.read(tags=Tag.input_dataset_calibration_frames(), decoder=json_decoder)
+    )
+    assert calibration_doc_from_file == expected_calibration_doc
+    expected_parameters_doc = FakeGQLClient.parameters_doc_object
+    parameters_doc_from_file = next(
+        task.read(tags=Tag.input_dataset_parameters(), decoder=json_decoder)
     )
-    doc_list_from_file = doc_from_file.model_dump()["doc_list"]
-    if (
-        tag == Tag.input_dataset_parameters()
-    ):  # parameter doc gets written with tags for file objects
-        for item in expected_doc:
-            for val in item["parameterValues"]:
-                if "__file__" in val["parameterValue"]:
-                    file_dict = json.loads(val["parameterValue"])["__file__"]
-                    file_dict["tag"] = Tag.parameter(Path(file_dict["objectKey"]).name)
-                    val["parameterValue"] = json.dumps({"__file__": file_dict})
-    assert doc_list_from_file == expected_doc
+    assert parameters_doc_from_file == expected_parameters_doc
 
 
-def test_download_dataset_missing_part(transfer_l0_data_task_missing_calibration_part):
+def test_download_dataset_missing_part(transfer_l0_data_task_missing_part):
     """
     :Given: a TransferL0Data task with a valid input dataset without calibration frames
     :When: downloading the dataset documents from the metadata store
     :Then: the correct number of documents are written to disk
     """
     # Given
-    task = transfer_l0_data_task_missing_calibration_part
+    task = transfer_l0_data_task_missing_part
     # When
     task.download_input_dataset()
     # Then
     observe_doc_from_file = next(
-        task.read(
-            tags=Tag.input_dataset_observe_frames(),
-            decoder=basemodel_decoder,
-            model=InputDatasetPartDocumentList,
-        )
+        task.read(tags=Tag.input_dataset_observe_frames(), decoder=json_decoder)
     )
     parameters_doc_from_file = next(
-        task.read(
-            tags=Tag.input_dataset_parameters(),
-            decoder=basemodel_decoder,
-            model=InputDatasetPartDocumentList,
-        )
+        task.read(tags=Tag.input_dataset_parameters(), decoder=json_decoder)
     )
     with pytest.raises(StopIteration):
         calibration_doc_from_file = next(
-            task.read(
-                tags=Tag.input_dataset_calibration_frames(),
-                decoder=basemodel_decoder,
-                model=InputDatasetPartDocumentList,
-            )
+            task.read(tags=Tag.input_dataset_calibration_frames(), decoder=json_decoder)
         )
 
 
-@pytest.mark.parametrize(
-    "task_name",
-    [
-        pytest.param(
-            "transfer_l0_data_task",
-            id="observe_and_calibration_frames",
-        ),
-        pytest.param(
-            "transfer_l0_data_task_missing_calibration_part",
-            id="calibration_frames_missing",
-        ),
-    ],
-)
-def test_build_frame_transfer_list_formatted(request, task_name):
+def test_format_frame_transfer_items(transfer_l0_data_task):
     """
-    :Given: a TransferL0Data task with downloaded input dataset docs
-    :When: building a list of frames in the input dataset formatted for transfer
-    :Then: the correct items are correctly loaded into GlobusTransferItem objects
+    :Given: a TransferL0Data task with a downloaded input dataset
+    :When: formatting frames in the input dataset for transfer
+    :Then: the items are correctly loaded into GlobusTransferItem objects
     """
     # Given
-    task = request.getfixturevalue(task_name)
+    task = transfer_l0_data_task
     task.download_input_dataset()
     # When
-    observe_transfer_objects = task.build_transfer_list(doc_tag=Tag.input_dataset_observe_frames())
-    calibration_transfer_objects = task.build_transfer_list(
-        doc_tag=Tag.input_dataset_calibration_frames()
-    )
-    transfer_objects = observe_transfer_objects + calibration_transfer_objects
-    formatted_transfer_items = task.format_transfer_items(input_dataset_objects=transfer_objects)
+    transfer_items = task.format_frame_transfer_items()
     # Then
     source_filenames = []
     destination_filenames = []
-    expected_frames = list(FakeGQLClient.observe_frames_doc_object)
-    if "missing_calibration_part" not in task_name:
-        expected_frames += FakeGQLClient.calibration_frames_doc_object
-    for frame_set in expected_frames:
+    all_frames = (
+        FakeGQLClient.observe_frames_doc_object + FakeGQLClient.calibration_frames_doc_object
+    )
+    for frame_set in all_frames:
         for key in frame_set["object_keys"]:
             source_filenames.append(os.path.join("/", frame_set["bucket"], key))
             destination_filenames.append(Path(key).name)
-    assert len(formatted_transfer_items) == len(source_filenames)
-    for item in formatted_transfer_items:
+    assert len(transfer_items) == len(source_filenames)
+    for item in transfer_items:
         assert item.source_path.as_posix() in source_filenames
         assert item.destination_path.name in destination_filenames
         assert not item.recursive
 
 
-def test_build_parameter_file_transfer_items(transfer_l0_data_task):
+def test_format_parameter_file_transfer_items(transfer_l0_data_task):
     """
-    :Given: a TransferL0Data task with downloaded input dataset docs
-    :When: building a list of parameter files formatted for transfer
-    :Then: the correct items are correctly loaded into GlobusTransferItem objects
+    :Given: a TransferL0Data task with a downloaded input dataset
+    :When: formatting parameter files in the input dataset for transfer
+    :Then: the items are correctly loaded into GlobusTransferItem objects
     """
     # Given
     task = transfer_l0_data_task
     task.download_input_dataset()
+    create_parameter_files(task)
     # When
-    transfer_objects = task.build_transfer_list(doc_tag=Tag.input_dataset_parameters())
-    formatted_transfer_items = task.format_transfer_items(input_dataset_objects=transfer_objects)
+    transfer_items = task.format_parameter_transfer_items()
     # Then
     source_filenames = []
     destination_filenames = []
@@ -213,44 +162,9 @@ def test_build_parameter_file_transfer_items(transfer_l0_data_task):
                 object_key = value_dict["__file__"]["objectKey"]
                 source_filenames.append(os.path.join("/", bucket, object_key))
                 destination_filenames.append(Path(object_key).name)
-    assert len(formatted_transfer_items) == len(source_filenames)
-    for transfer_item in formatted_transfer_items:
+    assert len(transfer_items) == len(source_filenames)
+    for transfer_item in transfer_items:
         assert transfer_item.source_path.as_posix() in source_filenames
         assert transfer_item.destination_path.name in destination_filenames
         assert str(transfer_item.destination_path).startswith(str(task.scratch.workflow_base_path))
         assert not transfer_item.recursive
-
-
-def test_tag_transfer_items(transfer_l0_data_task):
-    """
-    :Given: a TransferL0Data task with downloaded input dataset frames and parameter files
-    :When: tagging the downloaded files
-    :Then: the downloaded items are correctly tagged
-    """
-    # Given
-    task = transfer_l0_data_task
-    task.download_input_dataset()
-    observe_transfer_objects = task.build_transfer_list(doc_tag=Tag.input_dataset_observe_frames())
-    calibration_transfer_objects = task.build_transfer_list(
-        doc_tag=Tag.input_dataset_calibration_frames()
-    )
-    frame_transfer_objects = observe_transfer_objects + calibration_transfer_objects
-    create_input_frames(task)
-    parameter_transfer_objects = task.build_transfer_list(doc_tag=Tag.input_dataset_parameters())
-    create_parameter_files(task)
-    # When
-    transfer_objects = frame_transfer_objects + parameter_transfer_objects
-    task.tag_transfer_objects(input_dataset_objects=transfer_objects)
-    # Then
-    input_tags = [Tag.input(), Tag.frame()]
-    input_frames_on_disk = list(task.scratch.find_all(tags=input_tags))
-    for obj in frame_transfer_objects:
-        destination_path = task.scratch.absolute_path(obj.object_key)
-        assert destination_path in input_frames_on_disk
-    assert len(input_frames_on_disk) == len(frame_transfer_objects)
-    for obj in parameter_transfer_objects:
-        destination_path = task.scratch.absolute_path(obj.object_key)
-        param_tag = Tag.parameter(Path(obj.object_key))
-        param_file_on_disk = list(task.scratch.find_all(tags=param_tag))
-        assert destination_path in param_file_on_disk
-        assert len(param_file_on_disk) == 1

dkist_processing_common/tests/test_write_l1.py

@@ -25,7 +25,7 @@ from dkist_processing_common.tasks.write_l1 import WriteL1Frame
 from dkist_processing_common.tests.conftest import FakeGQLClient
 from dkist_processing_common.tests.conftest import TILE_SIZE
 from dkist_processing_common.tests.test_transfer_input_data import (
-    FakeGQLClientMissingInputDatasetCalibrationPart,
+    FakeGQLClientMissingInputDatasetPart,
 )
 
 
@@ -101,6 +101,12 @@ class CompleteWriteL1Frame(WriteL1Frame):
         return WavelengthRange(min=1075.0 * u.nm, max=1085.0 * u.nm)
 
 
+class CompleteWriteL1FrameWithEmptyWaveband(CompleteWriteL1Frame):
+    def get_wavelength_range(self, header: fits.Header) -> WavelengthRange:
+        # Return an empty range to test the empty waveband case
+        return WavelengthRange(min=10000.0 * u.nm, max=10050.0 * u.nm)
+
+
 @dataclass
 class FakeConstantDb:
     INSTRUMENT: str = "TEST"
@@ -157,9 +163,70 @@ def write_l1_task(request, recipe_run_id, tmp_path):
 @pytest.fixture(
     scope="function",
     params=[
-        pytest.param({"AO_LOCK": True}, id="AO_LOCK_True"),
-        pytest.param({"AO_LOCK": False}, id="AO_LOCK_False"),
-        pytest.param({}, id="AO_LOCK_missing"),
+        pytest.param((1, "complete_common_header"), id="Intensity"),
+        pytest.param((4, "complete_polarimetric_header"), id="Polarimetric"),
+    ],
+)
+def write_l1_task_with_empty_waveband(recipe_run_id, tmp_path, request):
+    with CompleteWriteL1FrameWithEmptyWaveband(
+        recipe_run_id=recipe_run_id,
+        workflow_name="workflow_name",
+        workflow_version="workflow_version",
+    ) as task:
+        task.scratch = WorkflowFileSystem(recipe_run_id=recipe_run_id, scratch_base_path=tmp_path)
+        num_of_stokes_params, header_fixture_name = request.param
+        header = request.getfixturevalue(header_fixture_name)
+        stokes_params = ["I", "Q", "U", "V"]
+        used_stokes_params = []
+        hdu = fits.PrimaryHDU(data=np.random.random(size=(1, 128, 128)) * 10, header=header)
+        hdu.header["IPTASK"] = "level0_only key to be removed"
+        hdul = fits.HDUList([hdu])
+        for i in range(num_of_stokes_params):
+            task.write(
+                data=hdul,
+                tags=[
+                    Tag.calibrated(),
+                    Tag.frame(),
+                    Tag.stokes(stokes_params[i]),
+                    Tag.dsps_repeat(i),
+                ],
+                encoder=fits_hdulist_encoder,
+            )
+            used_stokes_params.append(stokes_params[i])
+        task.constants._update(asdict(FakeConstantDb()))
+        yield task, used_stokes_params, header
+        task._purge()
+
+
+@pytest.fixture(
+    scope="function",
+    params=[
+        pytest.param(
+            {"AO_LOCK": True, "ATMOS_R0": 0.2, "OOBSHIFT": 17}, id="AO_LOCK_True_good_R0_good_oob"
+        ),
+        pytest.param(
+            {"AO_LOCK": True, "ATMOS_R0": 1, "OOBSHIFT": 17}, id="AO_LOCK_True_bad_R0_good_oob"
+        ),
+        pytest.param(
+            {"AO_LOCK": False, "ATMOS_R0": 0.2, "OOBSHIFT": 17}, id="AO_LOCK_False_good_R0_good_oob"
+        ),
+        pytest.param(
+            {"AO_LOCK": False, "ATMOS_R0": 1, "OOBSHIFT": 17}, id="AO_LOCK_False_bad_R0_good_oob"
+        ),
+        pytest.param(
+            {"AO_LOCK": True, "ATMOS_R0": 0.2, "OOBSHIFT": 150}, id="AO_LOCK_True_good_R0_bad_oob"
+        ),
+        pytest.param(
+            {"AO_LOCK": True, "ATMOS_R0": 1, "OOBSHIFT": 150}, id="AO_LOCK_True_bad_R0_bad_oob"
+        ),
+        pytest.param(
+            {"AO_LOCK": False, "ATMOS_R0": 0.2, "OOBSHIFT": 150}, id="AO_LOCK_False_good_R0_bad_oob"
+        ),
+        pytest.param(
+            {"AO_LOCK": False, "ATMOS_R0": 1, "OOBSHIFT": 150}, id="AO_LOCK_False_bad_R0_bad_oob"
+        ),
+        pytest.param({"ATMOS_R0": 0.2, "OOBSHIFT": 17}, id="AO_LOCK_missing"),
+        pytest.param({"ATMOS_R0": 0.2, "AO_LOCK": True}, id="OOBSHIFT_missing"),
     ],
 )
 def write_l1_task_no_data(request, recipe_run_id, tmp_path, complete_common_header):
@@ -172,10 +239,10 @@ def write_l1_task_no_data(request, recipe_run_id, tmp_path, complete_common_head
     ):
         task.scratch = WorkflowFileSystem(recipe_run_id=recipe_run_id, scratch_base_path=tmp_path)
         header = complete_common_header
-        header.pop("AO_LOCK", None)  # If it's not required, shouldn't be here in the first place??
+        header.pop("AO_LOCK", None)
+        header.pop("ATMOS_R0", None)
+        header.pop("OOBSHIFT", None)
         header.update(request.param)
-        fried_parameter = 0.2
-        header["ATMOS_R0"] = fried_parameter
         hdu = fits.PrimaryHDU(data=np.random.random(size=(1, 1, 1)) * 1, header=header)
         hdul = fits.HDUList([hdu])
         task.write(
@@ -187,7 +254,9 @@ def write_l1_task_no_data(request, recipe_run_id, tmp_path, complete_common_head
             encoder=fits_hdulist_encoder,
         )
         task.constants._update(asdict(FakeConstantDb()))
-        yield task, header, fried_parameter
+        fried_parameter = request.param["ATMOS_R0"]
+        oob_shift = request.param.get("OOBSHIFT")
+        yield task, header, fried_parameter, oob_shift
         task._purge()
 
 
@@ -503,7 +572,7 @@ def test_missing_input_dataset_part(write_l1_task, mocker):
     """
     mocker.patch(
         "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient",
-        new=FakeGQLClientMissingInputDatasetCalibrationPart,
+        new=FakeGQLClientMissingInputDatasetPart,
     )
     task, _, _ = write_l1_task
     task()
@@ -606,7 +675,7 @@ def test_check_r0_ao_lock(write_l1_task_no_data):
     :When: writing, check if the AO lock is on
     :Then: write the r0 value if AO lock on, don't write if AO lock off
     """
-    task, header, r0 = write_l1_task_no_data
+    task, header, r0, _ = write_l1_task_no_data
     header_after_check = task.remove_invalid_r0_values(header=header)
     if header.get("AO_LOCK"):
         assert header_after_check["ATMOS_R0"] == header["ATMOS_R0"]
@@ -616,3 +685,67 @@ def test_check_r0_ao_lock(write_l1_task_no_data):
         with pytest.raises(KeyError, match="Keyword 'ATMOS_R0' not found"):
             invalid_r0 = header_after_check["ATMOS_R0"]
         assert header.get("AO_LOCK") != True
+
+
+@pytest.mark.parametrize(
+    "wavelength, wavemin, wavemax, expected",
+    [
+        pytest.param(
+            617,
+            615,
+            619,
+            "Fe I (617.33 nm)",
+            id="line_is_between_wavemin_and_wavemax_and_exists",
+        ),
+        pytest.param(
+            700,
+            698,
+            702,
+            None,
+            id="line_is_between_wavemin_and_wavemax_and_does_not_exist",
+        ),
+        pytest.param(
+            617,
+            698,
+            702,
+            None,
+            id="line_is_not_between_wavemin_and_wavemax_and_exists",
+        ),
+    ],
+)
+def test_get_waveband(write_l1_task, wavelength, wavemin, wavemax, expected):
+    """
+    :Given: an input wavelength contribution
+    :When: determining the waveband
+    :Then: the correct waveband is returned
+    """
+    wavelength_range = WavelengthRange(min=wavemin * u.nm, max=wavemax * u.nm)
+    task, _, _ = write_l1_task
+    waveband = task.get_waveband(wavelength=wavelength * u.nm, wavelength_range=wavelength_range)
+    assert waveband == expected
+
+
+def test_empty_waveband(write_l1_task_with_empty_waveband, mocker):
+    """
+    :Given: a header converted to SPEC 214 L1 and a wavelength range that has no listed spectral lines
+    :When: checking the waveband key
+    :Then: it does not exist
+    """
+    mocker.patch(
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+    )
+    mocker.patch(
+        "dkist_processing_common.tasks.write_l1.WriteL1Frame.version_from_module_name",
+        new_callable=Mock,
+        return_value="fake_version_number",
+    )
+
+    task, _, _ = write_l1_task_with_empty_waveband
+    task()
+    files = list(task.read(tags=[Tag.frame(), Tag.output()]))
+    for file in files:
+        header = fits.open(file)[1].header
+        assert header["WAVEMIN"] == 10000
+        assert header["WAVEMAX"] == 10050
+        with pytest.raises(KeyError):
+            header["WAVEBAND"]

{dkist_processing_common-10.8.1rc1.dist-info → dkist_processing_common-10.8.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-common
-Version: 10.8.1rc1
+Version: 10.8.3
 Summary: Common task classes used by the DKIST science data processing pipelines
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause
@@ -17,7 +17,7 @@ Requires-Dist: asdf<4.0.0,>=3.5.0
 Requires-Dist: astropy>=7.0.0
 Requires-Dist: dkist-fits-specifications<5.0,>=4.0.0
 Requires-Dist: dkist-header-validator<6.0,>=5.0.0
-Requires-Dist: dkist-processing-core==5.1.0
+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