dkist-processing-visp 3.3.0__py3-none-any.whl → 5.1.1__py3-none-any.whl

dkist_processing_visp/tests/local_trial_workflows/local_trial_helpers.py

@@ -10,17 +10,20 @@ from dkist_header_validator import spec214_validator
 from dkist_processing_common.codecs.fits import fits_array_decoder
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_processing_common.models.constants import BudName
+from dkist_processing_common.models.fits_access import MetadataKey
 from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.parsers.cs_step import CSStepFlower
 from dkist_processing_common.parsers.cs_step import NumCSStepBud
 from dkist_processing_common.parsers.retarder import RetarderNameBud
-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 ExposureTimeFlower
 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.unique_bud import TaskUniqueBud
+from dkist_processing_common.parsers.unique_bud import UniqueBud
 from dkist_processing_common.tasks import ParseL0InputDataBase
 from dkist_processing_common.tasks import WorkflowTaskBase
 from dkist_processing_common.tasks.mixin.globus import GlobusTransferItem
@@ -30,10 +33,14 @@ from loguru import logger
 
 from dkist_processing_visp.models.constants import VispBudName
 from dkist_processing_visp.models.constants import VispConstants
+from dkist_processing_visp.models.fits_access import VispMetadataKey
+from dkist_processing_visp.models.metric_code import VispMetricCode
 from dkist_processing_visp.models.parameters import VispParsingParameters
 from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.models.task_name import VispTaskName
 from dkist_processing_visp.parsers.modulator_states import ModulatorStateFlower
+from dkist_processing_visp.parsers.spectrograph_configuration import IncidentLightAngleBud
+from dkist_processing_visp.parsers.spectrograph_configuration import ReflectedLightAngleBud
 from dkist_processing_visp.parsers.time import DarkReadoutExpTimePickyBud
 from dkist_processing_visp.parsers.time import NonDarkNonPolcalTaskReadoutExpTimesBud
 from dkist_processing_visp.parsers.visp_l0_fits_access import VispL0FitsAccess
@@ -263,7 +270,9 @@ class SaveSolarCal(SaveTaskTags):
     @property
     def tag_lists_to_save(self) -> list[list[str]]:
         return super().tag_lists_to_save + [
-            [VispTag.quality("TASK_TYPES"), VispTag.workflow_task("SolarCalibration")]
+            [VispTag.quality("TASK_TYPES"), VispTag.workflow_task("SolarCalibration")],
+            [VispTag.quality(VispMetricCode.solar_first_vignette)],
+            [VispTag.quality(VispMetricCode.solar_final_vignette)],
         ]
 
     @property
@@ -415,39 +424,55 @@ class ParseCalOnlyL0InputData(ParseL0InputDataBase):
     @property
     def constant_buds(self):
         """Add ViSP specific constants to common constants."""
+        # TODO: Subclass ViSP parse task and *remove* unneeded things from this list
         return super().constant_buds + [
+            UniqueBud(constant_name=VispBudName.arm_id.value, metadata_key=VispMetadataKey.arm_id),
             NumCSStepBud(self.parameters.max_cs_step_time_sec),
             NonDarkNonPolcalTaskReadoutExpTimesBud(),
             DarkReadoutExpTimePickyBud(),
             RetarderNameBud(),
+            IncidentLightAngleBud(),
+            ReflectedLightAngleBud(),
+            TaskUniqueBud(
+                constant_name=VispBudName.grating_constant_inverse_mm.value,
+                metadata_key=VispMetadataKey.grating_constant_inverse_mm,
+                ip_task_types=[TaskName.observe.value, TaskName.solar_gain.value],
+                task_type_parsing_function=parse_header_ip_task_with_gains,
+            ),
+            TaskUniqueBud(
+                constant_name=VispBudName.solar_gain_ip_start_time.value,
+                metadata_key=MetadataKey.ip_start_time,
+                ip_task_types=TaskName.solar_gain,
+                task_type_parsing_function=parse_header_ip_task_with_gains,
+            ),
             TaskExposureTimesBud(
                 stem_name=VispBudName.lamp_exposure_times.value,
-                ip_task_type=TaskName.lamp_gain.value,
+                ip_task_types=TaskName.lamp_gain.value,
                 header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
             TaskExposureTimesBud(
                 stem_name=VispBudName.solar_exposure_times.value,
-                ip_task_type=TaskName.solar_gain.value,
+                ip_task_types=TaskName.solar_gain.value,
                 header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
             TaskExposureTimesBud(
                 stem_name=VispBudName.polcal_exposure_times.value,
-                ip_task_type=TaskName.polcal.value,
+                ip_task_types=TaskName.polcal.value,
                 header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
             TaskReadoutExpTimesBud(
                 stem_name=VispBudName.lamp_readout_exp_times.value,
-                ip_task_type=TaskName.lamp_gain.value,
+                ip_task_types=TaskName.lamp_gain.value,
                 header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
             TaskReadoutExpTimesBud(
                 stem_name=VispBudName.solar_readout_exp_times.value,
-                ip_task_type=TaskName.solar_gain.value,
+                ip_task_types=TaskName.solar_gain.value,
                 header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
             TaskReadoutExpTimesBud(
                 stem_name=VispBudName.polcal_readout_exp_times.value,
-                ip_task_type=TaskName.polcal.value,
+                ip_task_types=TaskName.polcal.value,
                 header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
         ]
@@ -575,9 +600,9 @@ class TagSingleSolarGainAsScience(VispTaskBase):
         avg_array = average_numpy_arrays(arrays=arrays)
 
         hdul = fits.HDUList([fits.PrimaryHDU(data=avg_array, header=first_header)])
-        hdul[0].header["VSPSTP"] = 0
-        hdul[0].header["VSPNSTP"] = 1
-        hdul[0].header["VSPSTNUM"] = 1
+        hdul[0].header[VispMetadataKey.raster_scan_step] = 0
+        hdul[0].header[VispMetadataKey.total_raster_steps] = 1
+        hdul[0].header[VispMetadataKey.modulator_state] = 1
         hdul[0].header["VSPPOLMD"] = "observe_intensity"
         # hdul[0].header["POL_NOIS"] = 0.666
         # hdul[0].header["POL_SENS"] = 0.666
@@ -626,9 +651,9 @@ class TagModulatedSolarGainsAsScience(VispTaskBase):
             avg_array = average_numpy_arrays(arrays=arrays)
 
             hdul = fits.HDUList([fits.PrimaryHDU(data=avg_array, header=first_header)])
-            hdul[0].header["VSPSTP"] = 0
-            hdul[0].header["VSPNSTP"] = 1
-            hdul[0].header["VSPSTNUM"] = modstate
+            hdul[0].header[VispMetadataKey.raster_scan_step] = 0
+            hdul[0].header[VispMetadataKey.total_raster_steps] = 1
+            hdul[0].header[VispMetadataKey.modulator_state] = modstate
             hdul[0].header["VSPPOLMD"] = "observe_polarimetric"
 
             new_tags = [
@@ -691,3 +716,62 @@ def load_solar_gain_as_science_task(force_intensity_only: bool):
             logger.info(f"{self.constants.correct_for_polarization = }")
 
     return LoadSolarGainAsScience
+
+
+class SavePolcalAsScience(WorkflowTaskBase):
+    constants: VispConstants
+
+    @property
+    def constants_model_class(self):
+        """Get ViSP pipeline constants."""
+        return VispConstants
+
+    @property
+    def tag_lists_to_save(self) -> list[str]:
+        return [VispTag.task_observe(), VispTag.input(), VispTag.frame()]
+
+    @property
+    def relative_save_file(self) -> str:
+        return "polcal_as_science.asdf"
+
+    def run(self):
+        file_tag_dict = dict()
+        tag_list_list = self.tag_lists_to_save
+        if isinstance(tag_list_list[0], str):
+            tag_list_list = [tag_list_list]
+
+        pcas_constants = {
+            VispBudName.num_map_scans.value: self.constants.num_map_scans,
+            VispBudName.num_raster_steps.value: self.constants.num_raster_steps,
+        }
+
+        for tags_to_save in tag_list_list:
+            path_list = self.read(tags=tags_to_save)
+            save_dir = self.scratch.workflow_base_path / Path(self.relative_save_file).stem
+            save_dir.mkdir(exist_ok=True)
+            for p in path_list:
+                copied_path = shutil.copy(str(p), save_dir)
+                tags = self.tags(p)
+                file_tag_dict[copied_path] = tags
+
+        full_save_file = self.scratch.workflow_base_path / self.relative_save_file
+        tree = {"file_tag_dict": file_tag_dict, "pcas_constants": pcas_constants}
+        af = asdf.AsdfFile(tree)
+        af.write_to(full_save_file)
+        logger.info(f"Saved polcal science frames to {full_save_file}")
+
+
+class LoadPolcalAsScience(WorkflowTaskBase):
+    @property
+    def relative_save_file(self) -> str:
+        return "polcal_as_science.asdf"
+
+    def run(self):
+        full_save_file = self.scratch.workflow_base_path / self.relative_save_file
+        with asdf.open(full_save_file) as af:
+            for f, t in af.tree["file_tag_dict"].items():
+                self.tag(path=f, tags=t)
+
+            self.constants._db_dict.update(**af.tree["pcas_constants"])
+
+        logger.info(f"Loaded database entries from {full_save_file}")

dkist_processing_visp/tests/test_assemble_movie.py

@@ -1,6 +1,5 @@
 import pytest
 from dkist_processing_common._util.scratch import WorkflowFileSystem
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.tasks.assemble_movie import AssembleVispMovie
@@ -49,9 +48,9 @@ def assemble_task_with_tagged_movie_frames(tmp_path, recipe_run_id, init_visp_co
             task._purge()
 
 
-def test_assemble_movie(assemble_task_with_tagged_movie_frames, mocker):
+def test_assemble_movie(assemble_task_with_tagged_movie_frames, mocker, fake_gql_client):
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     task, num_maps = assemble_task_with_tagged_movie_frames
     write_movie_frames_to_task(task, num_maps)

dkist_processing_visp/tests/test_assemble_quality.py

@@ -1,27 +1,65 @@
+from typing import Generator
 from unittest.mock import MagicMock
 
+import numpy as np
 import pytest
+from dkist_processing_common._util.scratch import WorkflowFileSystem
+from dkist_processing_common.codecs.asdf import asdf_encoder
+from dkist_processing_common.codecs.quality import quality_data_decoder
 
+from dkist_processing_visp.models.metric_code import VispMetricCode
+from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.tasks.l1_output_data import VispAssembleQualityData
 
 
 @pytest.fixture
-def visp_assemble_quality_data_task(tmp_path, recipe_run_id) -> VispAssembleQualityData:
+def visp_assemble_quality_data_task(
+    tmp_path, recipe_run_id
+) -> Generator[VispAssembleQualityData, None, None]:
 
     with VispAssembleQualityData(
         recipe_run_id=recipe_run_id, workflow_name="visp_assemble_quality", workflow_version="VX.Y"
     ) as task:
+        task.scratch = WorkflowFileSystem(scratch_base_path=tmp_path, recipe_run_id=recipe_run_id)
         yield task
         task._purge()
 
 
+def write_raw_vignette_metrics_to_task(task):
+    for beam in [1, 2]:
+        dummy_vec = np.arange(10)
+        first_vignette_quality_outputs = {
+            "output_wave_vec": dummy_vec,
+            "input_spectrum": dummy_vec,
+            "best_fit_atlas": dummy_vec,
+            "best_fit_continuum": dummy_vec,
+            "residuals": dummy_vec,
+        }
+        task.write(
+            data=first_vignette_quality_outputs,
+            tags=[VispTag.quality(VispMetricCode.solar_first_vignette), VispTag.beam(beam)],
+            encoder=asdf_encoder,
+        )
+        final_correction_quality_outputs = {
+            "output_wave_vec": dummy_vec,
+            "median_spec": dummy_vec,
+            "low_deviation": dummy_vec,
+            "high_deviation": dummy_vec,
+        }
+        task.write(
+            data=final_correction_quality_outputs,
+            tags=[VispTag.quality(VispMetricCode.solar_final_vignette), VispTag.beam(beam)],
+            encoder=asdf_encoder,
+        )
+
+
 @pytest.fixture
 def dummy_quality_data() -> list[dict]:
     return [{"dummy_key": "dummy_value"}]
 
 
 @pytest.fixture
-def quality_assemble_data_mock(mocker, dummy_quality_data) -> MagicMock:
+def common_quality_assemble_data_mock(mocker, dummy_quality_data) -> MagicMock:
     yield mocker.patch(
         "dkist_processing_common.tasks.mixin.quality.QualityMixin.quality_assemble_data",
         return_value=dummy_quality_data,
@@ -29,13 +67,60 @@ def quality_assemble_data_mock(mocker, dummy_quality_data) -> MagicMock:
     )
 
 
-def test_correct_polcal_label_list(visp_assemble_quality_data_task, quality_assemble_data_mock):
+def test_vignette_metrics_built(visp_assemble_quality_data_task):
+    """
+    Given: A `VispAssembleQualityData` task with raw vignette metrics in scratch
+    When: Building the quality report data
+    Then: The vignette metrics are included in the data
+    """
+    task = visp_assemble_quality_data_task
+    write_raw_vignette_metrics_to_task(task)
+
+    task()
+
+    final_report_list = list(task.read(tags=VispTag.quality_data(), decoder=quality_data_decoder))
+    assert len(final_report_list) == 1
+    final_report = final_report_list[0]
+
+    initial_vignette_metrics = list(
+        filter(lambda i: i["name"].startswith("Initial Vignette Estimation"), final_report)
+    )
+    assert len(initial_vignette_metrics) == 2
+    facet_set = set()
+    for m in initial_vignette_metrics:
+        assert m["metric_code"] == VispMetricCode.solar_first_vignette.value
+        assert m["description"]
+        assert m["multi_plot_data"]
+        facet_set.add(m["facet"])
+
+    assert facet_set == {"BEAM_1", "BEAM_2"}
+
+    final_vignette_metrics = list(
+        filter(lambda i: i["name"].startswith("Final Vignette Estimation"), final_report)
+    )
+    assert len(final_vignette_metrics) == 2
+    facet_set = set()
+    for m in final_vignette_metrics:
+        assert m["metric_code"] == VispMetricCode.solar_final_vignette.value
+        assert m["description"]
+        assert m["multi_plot_data"]
+        facet_set.add(m["facet"])
+
+    assert facet_set == {"BEAM_1", "BEAM_2"}
+
+
+def test_correct_polcal_label_list(
+    visp_assemble_quality_data_task, common_quality_assemble_data_mock
+):
     """
     Given: A VispAssembleQualityData task
     When: Calling the task
     Then: The correct polcal_label_list property is passed to .quality_assemble_data
     """
     task = visp_assemble_quality_data_task
+    write_raw_vignette_metrics_to_task(task)
 
     task()
-    quality_assemble_data_mock.assert_called_once_with(task, polcal_label_list=["Beam 1", "Beam 2"])
+    common_quality_assemble_data_mock.assert_called_once_with(
+        task, polcal_label_list=["Beam 1", "Beam 2"]
+    )

dkist_processing_visp/tests/test_background_light.py

@@ -12,7 +12,6 @@ from dkist_header_validator.translator import translate_spec122_to_spec214_l0
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.models.task_name import TaskName
-from dkist_processing_common.tests.conftest import FakeGQLClient
 from dkist_processing_pac.fitter.fitter_parameters import PolcalDresserParameters
 from dkist_processing_pac.input_data.drawer import Drawer
 from dkist_processing_pac.input_data.dresser import Dresser
@@ -401,6 +400,7 @@ def test_background_light_calibration_task(
     num_polcal_dark_files,
     background_light,
     mocker,
+    fake_gql_client,
 ):
     """
     Give: a BackgroundLightCalibrationTask with a valid set of polcal data
@@ -408,7 +408,7 @@ def test_background_light_calibration_task(
     Then: BACKGROUND intermediate frames are generated for each beam
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     task_generator = background_light_calibration_task_factory()
     task = next(task_generator)
@@ -442,6 +442,7 @@ def test_background_light_bad_exposure_times(
     background_light_calibration_task_factory,
     constants_bad_exp_times,
     mocker,
+    fake_gql_client,
 ):
     """
     Given: A set of data where the polcal exposure times don't match those of solar gain and observe
@@ -449,7 +450,7 @@ def test_background_light_bad_exposure_times(
     Then: An error is raised
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     task_generator = background_light_calibration_task_factory(constants=constants_bad_exp_times)
     task = next(task_generator)
@@ -461,6 +462,7 @@ def test_background_light_non_polarimetric_dataset(
     background_light_calibration_task_factory,
     constants_nor_polarimetric,
     mocker,
+    fake_gql_client,
 ):
     """
     Given: A dataset that is non-polarimetric (i.e., Stokes-I only)
@@ -468,7 +470,7 @@ def test_background_light_non_polarimetric_dataset(
     Then: Nothing is done and no files are written
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
 
     task_generator = background_light_calibration_task_factory(constants=constants_nor_polarimetric)
@@ -485,6 +487,7 @@ def test_background_light_non_polarimetric_dataset(
 def test_background_light_switch_off(
     background_light_calibration_task_factory,
     mocker,
+    fake_gql_client,
 ):
     """
     Given: A task with the background light switch turned off
@@ -492,7 +495,7 @@ def test_background_light_switch_off(
     Then: Nothing is done and no files are written
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     task_generator = background_light_calibration_task_factory(background_on=False)
     task = next(task_generator)

dkist_processing_visp/tests/test_dark.py

@@ -6,7 +6,6 @@ import pytest
 from astropy.io import fits
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.models.tags import Tag
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.tasks.dark import DarkCalibration
@@ -90,14 +89,16 @@ def dark_calibration_task(tmp_path, init_visp_constants_db, recipe_run_id):
             task._purge()
 
 
-def test_dark_calibration_task(dark_calibration_task, assign_input_dataset_doc_to_task, mocker):
+def test_dark_calibration_task(
+    dark_calibration_task, assign_input_dataset_doc_to_task, mocker, fake_gql_client
+):
     """
     Given: A DarkCalibration task with multiple task exposure times
     When: Calling the task instance
     Then: Only one average intermediate dark frame exists for each exposure time and unused times are not made
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     # Given
     task, readout_exp_times = dark_calibration_task

dkist_processing_visp/tests/test_fits_access.py

@@ -0,0 +1,43 @@
+import pytest
+from dkist_header_validator.translator import translate_spec122_to_spec214_l0
+
+from dkist_processing_visp.models.fits_access import VispMetadataKey
+from dkist_processing_visp.parsers.visp_l0_fits_access import VispL0FitsAccess
+from dkist_processing_visp.parsers.visp_l1_fits_access import VispL1FitsAccess
+from dkist_processing_visp.tests.header_models import VispHeadersValidObserveFrames
+
+
+@pytest.fixture(scope="session")
+def complete_header():
+    dataset = VispHeadersValidObserveFrames(
+        array_shape=(1, 1, 1),
+        time_delta=10,
+        num_maps=1,
+        num_raster_steps=1,
+        num_modstates=1,
+    )
+    header = translate_spec122_to_spec214_l0(dataset.header())
+    return header
+
+
+def test_metadata_keys_in_access_bases(complete_header):
+    """
+    Given: the set of metadata key names in VispMetadataKey
+    When: the ViSP FITS access classes define a set of new attributes
+    Then: the sets are the same and the attributes have the correct values
+    """
+    # Given
+    visp_metadata_key_names = {vmk.name for vmk in VispMetadataKey}
+    # When
+    all_visp_fits_access_attrs = set()
+    for access_class in [VispL0FitsAccess, VispL1FitsAccess]:
+        fits_obj = access_class.from_header(complete_header)
+        visp_instance_attrs = set(vars(fits_obj).keys())
+        parent_class = access_class.mro()[1]
+        parent_fits_obj = parent_class.from_header(complete_header)
+        parent_instance_attrs = set(vars(parent_fits_obj).keys())
+        visp_fits_access_attrs = visp_instance_attrs - parent_instance_attrs
+        for attr in visp_fits_access_attrs:
+            assert getattr(fits_obj, attr) == fits_obj.header[VispMetadataKey[attr]]
+        all_visp_fits_access_attrs |= visp_fits_access_attrs
+    assert visp_metadata_key_names == all_visp_fits_access_attrs

dkist_processing_visp/tests/test_geometric.py

@@ -7,14 +7,13 @@ import pytest
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.fits import fits_array_decoder
 from dkist_processing_common.models.tags import Tag
-from dkist_processing_common.tests.conftest import FakeGQLClient
 from dkist_processing_math import transform
 
 from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.tasks.geometric import GeometricCalibration
-from dkist_processing_visp.tests.conftest import tag_on_modstate
 from dkist_processing_visp.tests.conftest import VispConstantsDb
 from dkist_processing_visp.tests.conftest import VispInputDatasetParameterValues
+from dkist_processing_visp.tests.conftest import tag_on_modstate
 from dkist_processing_visp.tests.conftest import write_frames_to_task
 from dkist_processing_visp.tests.conftest import write_intermediate_darks_to_task
 from dkist_processing_visp.tests.header_models import VispHeadersInputLampGainFrames
@@ -189,7 +188,9 @@ def geometric_calibration_task(tmp_path, recipe_run_id, init_visp_constants_db):
             task._purge()
 
 
-def test_geometric_task(geometric_calibration_task, assign_input_dataset_doc_to_task, mocker):
+def test_geometric_task(
+    geometric_calibration_task, assign_input_dataset_doc_to_task, mocker, fake_gql_client
+):
     """
     Given: A set of raw solar gain images and necessary intermediate calibrations
     When: Running the geometric task
@@ -201,7 +202,7 @@ def test_geometric_task(geometric_calibration_task, assign_input_dataset_doc_to_
     # tests for that. In other words, this fixture just tests if the machinery of the task completes and some object
     # (ANY object) is written correctly.
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     task, readout_exp_times, num_modstates = geometric_calibration_task
     dark_signal = 3.0
@@ -357,3 +358,43 @@ def test_basic_corrections(geometric_calibration_task, assign_input_dataset_doc_
             lamp_array = task.basic_corrected_lamp_data(beam=beam, modstate=modstate)
             np.testing.assert_equal(expected, solar_array)
             np.testing.assert_equal(expected, lamp_array)
+
+
+def test_line_zones(geometric_calibration_task):
+    """
+    Given: A spectrum with some absorption lines
+    When: Computing zones around the lines
+    Then: Correct results are returned
+    """
+
+    # NOTE that it does not test for removal of overlapping regions
+    def gaussian(x, amp, mu, sig):
+        return amp * np.exp(-np.power(x - mu, 2.0) / (2 * np.power(sig, 2.0)))
+
+    spec = np.ones(1000) * 100
+    x = np.arange(1000.0)
+    expected = []
+    for m, s in zip([100.0, 300.0, 700], [10.0, 20.0, 5.0]):
+        spec -= gaussian(x, 40, m, s)
+        hwhm = s * 2.355 / 2
+        expected.append((np.floor(m - hwhm).astype(int), np.ceil(m + hwhm).astype(int)))
+
+    task = geometric_calibration_task[0]
+
+    zones = task.compute_line_zones(spec[:, None], bg_order=0, rel_height=0.5)
+    assert zones == expected
+
+
+def test_identify_overlapping_zones(geometric_calibration_task):
+    """
+    Given: A list of zone borders that contain overlapping zones
+    When: Identifying zones that overlap
+    Then: The smaller of the overlapping zones are identified for removal
+    """
+    rips = np.array([100, 110, 220, 200])
+    lips = np.array([150, 120, 230, 250])
+
+    task = geometric_calibration_task[0]
+
+    idx_to_remove = task.identify_overlapping_zones(rips, lips)
+    assert idx_to_remove == [1, 2]

dkist_processing_visp/tests/test_instrument_polarization.py

@@ -6,7 +6,6 @@ import pytest
 from astropy.io import fits
 from dkist_data_simulator.spec122 import Spec122Dataset
 from dkist_processing_common._util.scratch import WorkflowFileSystem
-from dkist_processing_common.tests.conftest import FakeGQLClient
 from dkist_processing_pac.fitter.polcal_fitter import PolcalFitter
 from dkist_processing_pac.input_data.dresser import Dresser
 
@@ -213,6 +212,7 @@ def test_instrument_polarization_calibration_task(
     background_on,
     assign_input_dataset_doc_to_task,
     mocker,
+    fake_gql_client,
 ):
     """
     Given: An InstrumentPolarizationCalibration task
@@ -221,7 +221,7 @@ def test_instrument_polarization_calibration_task(
     """
 
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     mocker.patch(
         "dkist_processing_visp.tasks.instrument_polarization.PolcalFitter",
@@ -255,7 +255,8 @@ def test_instrument_polarization_calibration_task(
         task=task, num_modstates=num_modstates, data_shape=intermediate_shape
     )
     write_dummy_intermediate_solar_cals_to_task(
-        task=task, data_shape=intermediate_shape, num_modstates=num_modstates
+        task=task,
+        data_shape=intermediate_shape,
     )
     write_input_polcals_to_task(
         task=task,