dkist-processing-vbi 1.21.1__py3-none-any.whl → 1.25.2__py3-none-any.whl

dkist_processing_vbi/__init__.py

@@ -1,4 +1,5 @@
 """Package providing support classes and methods used by all workflow tasks."""
+
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version
 

dkist_processing_vbi/config.py

@@ -1,4 +1,5 @@
 """Configuration for the dkist-processing-vbi package and the logging thereof."""
+
 from dkist_processing_common.config import DKISTProcessingCommonConfiguration
 
 

dkist_processing_vbi/models/constants.py

@@ -1,4 +1,5 @@
 """VBI additions to common constants."""
+
 from enum import Enum
 
 from dkist_processing_common.models.constants import ConstantsBase

dkist_processing_vbi/models/filter.py

@@ -1,4 +1,5 @@
 """VBI filter list and tooling."""
+
 import astropy.units as u
 from dkist_processing_common.models.wavelength import WavelengthRange
 

dkist_processing_vbi/models/parameters.py

@@ -1,4 +1,5 @@
 """VBI calibration pipeline parameters."""
+
 from dkist_processing_common.models.parameters import ParameterBase
 
 

dkist_processing_vbi/models/tags.py

@@ -1,4 +1,5 @@
 """VBI tags."""
+
 from enum import Enum
 
 from dkist_processing_common.models.tags import Tag

dkist_processing_vbi/parsers/mosaic_repeats.py

@@ -1,4 +1,5 @@
 """Stems for organizing files based on their Mosaic repeat number."""
+
 from __future__ import annotations
 
 from abc import ABC

dkist_processing_vbi/parsers/spatial_step_pattern.py

@@ -1,4 +1,5 @@
 """Bud for checking that the spatial step pattern (VBISTPAT) matches expectations."""
+
 from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
 
@@ -23,7 +24,7 @@ class SpatialStepPatternBud(TaskUniqueBud):
         super().__init__(
             constant_name=VbiBudName.spatial_step_pattern.value,
             metadata_key="spatial_step_pattern",
-            ip_task_type=TaskName.observe.value,
+            ip_task_types=TaskName.observe.value,
         )
 
     def getter(self, key):

dkist_processing_vbi/parsers/vbi_l0_fits_access.py

@@ -1,4 +1,5 @@
 """VBI FITS access for L0 data."""
+
 from astropy.io import fits
 from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
 

dkist_processing_vbi/parsers/vbi_l1_fits_access.py

@@ -1,4 +1,5 @@
 """VBI FITS access for L1 data."""
+
 from astropy.io import fits
 from dkist_processing_common.parsers.l1_fits_access import L1FitsAccess
 

dkist_processing_vbi/tasks/__init__.py

@@ -1,4 +1,5 @@
 """init."""
+
 from dkist_processing_vbi.tasks.assemble_movie import *
 from dkist_processing_vbi.tasks.dark import *
 from dkist_processing_vbi.tasks.gain import *

dkist_processing_vbi/tasks/assemble_movie.py

@@ -1,11 +1,13 @@
 """VBI-specific assemble movie task subclass."""
+
 from typing import Type
 
 import numpy as np
 from astropy.visualization import ZScaleInterval
+from dkist_processing_common.codecs.json import json_decoder
 from dkist_processing_common.models.constants import ConstantsBase
+from dkist_processing_common.models.input_dataset import InputDatasetPartDocumentList
 from dkist_processing_common.tasks import AssembleMovie
-from dkist_processing_common.tasks.mixin.input_dataset import InputDatasetMixin
 from matplotlib import colormaps
 from PIL import ImageDraw
 
@@ -17,7 +19,7 @@ from dkist_processing_vbi.parsers.vbi_l1_fits_access import VbiL1FitsAccess
 __all__ = ["AssembleVbiMovie"]
 
 
-class AssembleVbiMovie(AssembleMovie, InputDatasetMixin):
+class AssembleVbiMovie(AssembleMovie):
     """
     Class for assembling pre-made movie frames (as FITS/numpy) into an mp4 movie file.
 
@@ -45,7 +47,7 @@ class AssembleVbiMovie(AssembleMovie, InputDatasetMixin):
             workflow_version=workflow_version,
         )
         self.parameters = VbiParameters(
-            self.input_dataset_parameters,
+            scratch=self.scratch,
             obs_ip_start_time=self.constants.obs_ip_start_time,
         )
 

dkist_processing_vbi/tasks/dark.py

@@ -1,4 +1,5 @@
 """VBI dark calibration task."""
+
 from dkist_processing_common.codecs.fits import fits_array_decoder
 from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.models.task_name import TaskName
@@ -46,7 +47,7 @@ class DarkCalibration(VbiTaskBase, QualityMixin):
             set(self.constants.gain_exposure_times + self.constants.observe_exposure_times)
         )
         logger.info(f"{target_exp_times = }")
-        with self.apm_task_step(
+        with self.telemetry_span(
             f"Calculating dark frames for {self.constants.num_spatial_steps} steps and {len(target_exp_times)} exp times",
         ):
             total_dark_frames_used = 0
@@ -67,16 +68,14 @@ class DarkCalibration(VbiTaskBase, QualityMixin):
                         auto_squeeze=False,
                     )
 
-                    with self.apm_processing_step(
-                        f"Processing dark for {step = } and {exp_time = }"
-                    ):
+                    with self.telemetry_span(f"Processing dark for {step = } and {exp_time = }"):
                         logger.info(f"averaging arrays for step {step}")
                         averaged_dark_array = average_numpy_arrays(input_dark_arrays)
                         logger.info(
                             f"average dark signal in step {step} = {averaged_dark_array.mean():.3e}"
                         )
 
-                    with self.apm_writing_step(
+                    with self.telemetry_span(
                         f"Writing intermediate dark for {step = } and {exp_time = }",
                     ):
                         self.write(
@@ -88,7 +87,7 @@ class DarkCalibration(VbiTaskBase, QualityMixin):
                             encoder=fits_array_encoder,
                         )
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+        with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_dark_frames: int = self.count(tags=[VbiTag.input(), VbiTag.task_dark_frame()])
             unused_count = no_of_raw_dark_frames - total_dark_frames_used
             self.quality_store_task_type_counts(

dkist_processing_vbi/tasks/gain.py

@@ -1,4 +1,5 @@
 """VBI gain task."""
+
 import numpy as np
 from dkist_processing_common.codecs.fits import fits_array_decoder
 from dkist_processing_common.codecs.fits import fits_array_encoder
@@ -52,7 +53,7 @@ class GainCalibration(VbiTaskBase, QualityMixin):
         # This is OK (tm) because this will be, at most, 9 4k x 4k arrays. This is a lot (~1G), but not too much.
         step_gain_dict: dict = {}
 
-        with self.apm_processing_step(
+        with self.telemetry_span(
             f"Collecting and reducing gain arrays from {self.constants.num_spatial_steps} steps and {len(self.constants.gain_exposure_times)} exp times",
         ):
             for exp_time in self.constants.gain_exposure_times:
@@ -99,13 +100,13 @@ class GainCalibration(VbiTaskBase, QualityMixin):
                     self.total_counts += np.nansum(dark_subtracted_gain_array)
                     step_gain_dict[step] = dark_subtracted_gain_array
 
-        with self.apm_processing_step("normalizing gain arrays"):
+        with self.telemetry_span("normalizing gain arrays"):
             normalized_array_dict = self.normalize_fov(step_gain_dict)
 
-        with self.apm_writing_step("writing gain arrays to disk"):
+        with self.telemetry_span("writing gain arrays to disk"):
             self.write_gain_calibration(normalized_array_dict)
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+        with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_gain_frames: int = self.count(
                 tags=[
                     VbiTag.input(),

dkist_processing_vbi/tasks/make_movie_frames.py

@@ -1,4 +1,5 @@
 """VBI movie frame creation."""
+
 import numpy as np
 import scipy.ndimage as spnd
 from astropy.io import fits
@@ -43,15 +44,15 @@ class MakeVbiMovieFrames(VbiTaskBase):
         None
 
         """
-        with self.apm_processing_step("averaging exposures"):
+        with self.telemetry_span("averaging exposures"):
             self.average_all_exposures()
 
-        with self.apm_processing_step("stitching full FOV frames"):
+        with self.telemetry_span("stitching full FOV frames"):
             for mosaic in range(1, self.constants.num_mosaic_repeats + 1):
                 logger.info(f"stitching full FOV for mosaic repeat {mosaic}")
                 output_hdl = self.stitch_single_mosaic_repeat(mosaic)
 
-                with self.apm_writing_step(
+                with self.telemetry_span(
                     f"writing stitched movie frame for mosaic repeat {mosaic}"
                 ):
                     self.write(
@@ -144,9 +145,7 @@ class MakeVbiMovieFrames(VbiTaskBase):
         output = np.zeros((size_y, size_x))
         px_count = np.zeros((size_y, size_x))
 
-        with self.apm_processing_step(
-            f"stitching all camera positions together for {mosaic_repeat=}"
-        ):
+        with self.telemetry_span(f"stitching all camera positions together for {mosaic_repeat=}"):
             for o in all_step_access:
                 logger.info(f"Placing position {o.current_spatial_step} into full frame")
                 self.place_pos_in_full_fov(o, ref_header, output, px_count)

dkist_processing_vbi/tasks/parse.py

@@ -1,4 +1,5 @@
 """VBI parse task."""
+
 from dkist_processing_common.models.tags import StemName
 from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.parsers.single_value_single_key_flower import (
@@ -55,10 +56,10 @@ class ParseL0VbiInputData(ParseL0InputDataBase):
             ObsIpStartTimeBud(),
             TotalMosaicRepeatsBud(),
             TaskExposureTimesBud(
-                VbiBudName.gain_exposure_times.value, ip_task_type=TaskName.gain.value
+                VbiBudName.gain_exposure_times.value, ip_task_types=TaskName.gain.value
             ),
             TaskExposureTimesBud(
-                VbiBudName.observe_exposure_times.value, ip_task_type=TaskName.observe.value
+                VbiBudName.observe_exposure_times.value, ip_task_types=TaskName.observe.value
             ),
         ]
 

dkist_processing_vbi/tasks/process_summit_processed.py

@@ -1,4 +1,5 @@
 """Repackage VBI data already calibrated before receipt at the Data Center."""
+
 from astropy.io import fits
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 
@@ -33,7 +34,7 @@ class GenerateL1SummitData(VbiTaskBase):
             - Write out
         """
         # This loop is how we ensure that only completed mosaics get processed.
-        with self.apm_task_step("Re-tagging INPUT observe frames as CALIBRATED"):
+        with self.telemetry_span("Re-tagging INPUT observe frames as CALIBRATED"):
             for mosaic in range(1, self.constants.num_mosaic_repeats + 1):
                 for step in range(1, self.constants.num_spatial_steps + 1):
                     for file_name in self.read(

dkist_processing_vbi/tasks/quality_metrics.py

@@ -1,4 +1,5 @@
 """VBI specific quality metrics."""
+
 from typing import Iterable
 
 from dkist_processing_common.codecs.fits import fits_access_decoder
@@ -61,10 +62,10 @@ class VbiQualityL1Metrics(VbiTaskBase, QualityMixin):
         )
         datetimes = []
         noise_values = []
-        with self.apm_processing_step("Calculating VBI L1 quality metrics"):
+        with self.telemetry_span("Calculating VBI L1 quality metrics"):
             for frame in frames:
                 datetimes.append(frame.time_obs)
                 noise_values.append(self.avg_noise(frame.data))
 
-        with self.apm_processing_step("Sending lists for storage"):
+        with self.telemetry_span("Sending lists for storage"):
             self.quality_store_noise(datetimes=datetimes, values=noise_values)

dkist_processing_vbi/tasks/science.py

@@ -1,4 +1,5 @@
 """VBI science task."""
+
 from astropy.io import fits
 from dkist_processing_common.codecs.fits import fits_access_decoder
 from dkist_processing_common.codecs.fits import fits_array_decoder
@@ -48,7 +49,7 @@ class ScienceCalibration(VbiTaskBase, QualityMixin):
         logger.info(
             f"Starting science with {self.constants.num_spatial_steps} steps and {self.constants.num_mosaic_repeats} mosaic repeats"
         )
-        with self.apm_task_step(
+        with self.telemetry_span(
             f"Reducing science frames from {self.constants.num_spatial_steps} steps and {self.constants.num_mosaic_repeats} mosaic repeats",
         ):
             for exp_time in self.constants.observe_exposure_times:
@@ -88,7 +89,7 @@ class ScienceCalibration(VbiTaskBase, QualityMixin):
                             auto_squeeze=False,
                         )
 
-                        with self.apm_processing_step("dark and gain corrections"):
+                        with self.telemetry_span("dark and gain corrections"):
                             logger.info(f"subtracting dark from {apm_str}")
                             sci_access = subtract_array_from_fits_access(
                                 access_objs=sci_access, array_to_subtract=dark_calibration_array
@@ -99,13 +100,13 @@ class ScienceCalibration(VbiTaskBase, QualityMixin):
                                 access_objs=sci_access, array_to_divide_by=gain_calibration_array
                             )
 
-                        with self.apm_writing_step("writing calibrated science frames"):
+                        with self.telemetry_span("writing calibrated science frames"):
                             for i, access_obj in enumerate(sci_access):
                                 exp_num = access_obj.current_mosaic_step_exp
                                 logger.info(f"Writing output for {apm_str} and {exp_num = }")
                                 self.write_calibrated_fits_obj(access_obj, mosaic, step)
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+        with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_obs_frames: int = self.count(
                 tags=[
                     VbiTag.input(),

dkist_processing_vbi/tasks/vbi_base.py

@@ -1,13 +1,13 @@
 """VBI base task."""
+
 from abc import ABC
 
 from dkist_processing_common.tasks import WorkflowTaskBase
-from dkist_processing_common.tasks.mixin.input_dataset import InputDatasetMixin
 
 from dkist_processing_vbi.models.constants import VbiConstants
 
 
-class VbiTaskBase(WorkflowTaskBase, InputDatasetMixin, ABC):
+class VbiTaskBase(WorkflowTaskBase, ABC):
     """
     Task class for base VBI tasks.
 

dkist_processing_vbi/tasks/write_l1.py

@@ -1,4 +1,5 @@
 """VBI Write L1 task."""
+
 from typing import Literal
 from typing import Type
 
@@ -13,6 +14,7 @@ from dkist_processing_common.tasks.write_l1 import WriteL1Frame
 from dkist_service_configuration.logging import logger
 
 from dkist_processing_vbi.models.constants import VbiConstants
+from dkist_processing_vbi.models.filter import VBI_FILTERS
 from dkist_processing_vbi.models.filter import find_associated_filter
 
 __all__ = ["VbiWriteL1Frame"]
@@ -160,3 +162,7 @@ class VbiWriteL1Frame(WriteL1Frame):
         """
         vbi_filter = find_associated_filter(wavelength=header["LINEWAV"] * u.nm)
         return WavelengthRange(min=vbi_filter.min, max=vbi_filter.max)
+
+    def get_waveband(self, wavelength: u.Quantity, wavelength_range: WavelengthRange) -> str:
+        """Get the name of the filter that includes the given wavelength."""
+        return find_associated_filter(wavelength=wavelength).name

dkist_processing_vbi/tests/conftest.py

@@ -13,7 +13,10 @@ from dkist_data_simulator.dataset import key_function
 from dkist_data_simulator.spec122 import Spec122Dataset
 from dkist_header_validator.translator import sanitize_to_spec214_level1
 from dkist_header_validator.translator import translate_spec122_to_spec214_l0
+from dkist_processing_common.codecs.basemodel import basemodel_encoder
+from dkist_processing_common.models.input_dataset import InputDatasetPartDocumentList
 from dkist_processing_common.models.task_name import TaskName
+from dkist_processing_common.tests.mock_metadata_store import fake_gql_client
 
 from dkist_processing_vbi.models.constants import VbiConstants
 from dkist_processing_vbi.models.parameters import VbiParameters
@@ -93,6 +96,10 @@ class VbiS122Headers(Spec122Dataset):
         self.add_constant_key("VBI__003", num_steps)
         self.add_constant_key("VBI__007", num_exp_per_step)
         self.add_constant_key("DKIST008", DKIST008_value)
+        self.add_constant_key("ID___014", "v1")  # hls_version
+        self.add_constant_key("TELTRACK", "Fixed Solar Rotation Tracking")
+        self.add_constant_key("TTBLTRCK", "fixed angle on sun")
+        self.add_constant_key("TELSCAN", "Raster")
 
     @key_function("VBI__004")
     def spatial_step(self, key: str) -> int:
@@ -120,6 +127,13 @@ class Vbi122DarkFrames(VbiS122Headers):
             array_shape, num_steps=num_steps, num_exp_per_step=num_exp_per_step, num_dsps_repeats=1
         )
         self.add_constant_key("DKIST004", TaskName.dark.value)
+        self.add_constant_key("PAC__002", "clear")
+        self.add_constant_key("PAC__003", "off")
+        self.add_constant_key("PAC__004", "clear")
+        self.add_constant_key("PAC__005", "10.")
+        self.add_constant_key("PAC__006", "clear")
+        self.add_constant_key("PAC__007", "20.")
+        self.add_constant_key("PAC__008", "FieldStop (5arcmin)")
 
 
 class Vbi122GainFrames(VbiS122Headers):
@@ -297,7 +311,7 @@ def testing_obs_ip_start_time() -> str:
 def input_dataset_document_simple_parameters_part():
     """Convert a dataclass of parameterValues into an actual input dataset parameters part."""
 
-    def get_input_dataset_parameters_part(parameter_values: dataclass):
+    def make_input_dataset_parameters_part(parameter_values: dataclass):
         parameters_list = []
         value_id = randint(1000, 2000)
         for pn, pv in asdict(parameter_values).items():
@@ -312,7 +326,7 @@ def input_dataset_document_simple_parameters_part():
             parameters_list.append(parameter)
         return parameters_list
 
-    return get_input_dataset_parameters_part
+    return make_input_dataset_parameters_part
 
 
 @pytest.fixture(scope="session")
@@ -325,12 +339,15 @@ def assign_input_dataset_doc_to_task(
         parameter_class=VbiParameters,
         obs_ip_start_time=testing_obs_ip_start_time,
     ):
-        doc_path = task.scratch.workflow_base_path / "dataset_parameters.json"
-        with open(doc_path, "w") as f:
-            f.write(json.dumps(input_dataset_document_simple_parameters_part(parameter_values)))
-        task.tag(doc_path, VbiTag.input_dataset_parameters())
+        task.write(
+            data=InputDatasetPartDocumentList(
+                doc_list=input_dataset_document_simple_parameters_part(parameter_values)
+            ),
+            tags=VbiTag.input_dataset_parameters(),
+            encoder=basemodel_encoder,
+        )
         task.parameters = parameter_class(
-            task.input_dataset_parameters,
+            scratch=task.scratch,
             obs_ip_start_time=obs_ip_start_time,
         )
 

dkist_processing_vbi/tests/local_trial_workflows/l0_to_l1.py

@@ -10,7 +10,9 @@ import numpy as np
 from astropy.io import fits
 from dkist_header_validator import spec122_validator
 from dkist_header_validator import spec214_validator
+from dkist_processing_common.codecs.basemodel import basemodel_encoder
 from dkist_processing_common.manual import ManualProcessing
+from dkist_processing_common.models.input_dataset import InputDatasetPartDocumentList
 from dkist_processing_common.tasks import AssembleQualityData
 from dkist_processing_common.tasks import CreateTrialAsdf
 from dkist_processing_common.tasks import CreateTrialQualityReport
@@ -100,11 +102,16 @@ def translate_task(summit_processed: bool = False, suffix: str = "FITS"):
 
 class CreateInputDatasetParameterDocument(WorkflowTaskBase):
     def run(self) -> None:
-        doc_path = self.scratch.workflow_base_path / "input_dataset_parameters.json"
-        with open(doc_path, "w") as f:
-            f.write(json.dumps(self.input_dataset_document_simple_parameters_part))
-        self.tag(doc_path, VbiTag.input_dataset_parameters())
-        logger.info(f"Wrote input dataset doc to {doc_path}")
+        relative_path = "input_dataset_parameters.json"
+        self.write(
+            data=InputDatasetPartDocumentList(
+                doc_list=self.input_dataset_document_simple_parameters_part
+            ),
+            relative_path=relative_path,
+            tags=VbiTag.input_dataset_parameters(),
+            encoder=basemodel_encoder,
+        )
+        logger.info(f"Wrote input dataset parameter doc to {relative_path}")
 
     @property
     def input_dataset_document_simple_parameters_part(self):
@@ -139,21 +146,6 @@ class ValidateL1Output(VbiTaskBase):
             spec214_validator.validate(f, extra=False)
 
 
-def setup_APM_config() -> None:
-    mesh_config = {
-        "system-monitoring-log-apm": {
-            "mesh_address": "system-monitoring-log-apm.service.sim.consul",
-            "mesh_port": 8200,
-        },
-        "automated-processing-scratch-inventory": {"mesh_address": "localhost", "mesh_port": 6379},
-        "internal-api-gateway": {"mesh_address": "localhost", "mesh_port": 80},
-    }
-    apm_options = {"TRANSACTION_MAX_SPANS": 10000}
-    os.environ["MESH_CONFIG"] = json.dumps(mesh_config)
-    os.environ["ELASTIC_APM_ENABLED"] = "true"
-    os.environ["ELASTIC_APM_OTHER_OPTIONS"] = json.dumps(apm_options)
-
-
 def l0_pipeline_workflow(manual_processing_run: ManualProcessing) -> None:
     manual_processing_run.run_task(task=ShowExposureTimes)
     manual_processing_run.run_task(task=VbiQualityL0Metrics)
@@ -174,10 +166,7 @@ def main(
     skip_movie: bool = False,
     only_translate: bool = False,
     science_workflow_name: str = "l0_processing",
-    use_apm: bool = False,
 ):
-    if use_apm:
-        setup_APM_config()
     science_func_dict = {
         "l0_pipeline": l0_pipeline_workflow,
         "summit_data_processed": summit_data_processing_workflow,
@@ -258,7 +247,6 @@ if __name__ == "__main__":
         "-t", "--only-translate", help="Do ONLY the translation step", action="store_true"
     )
     parser.add_argument("-M", "--skip-movie", help="Skip making output movie", action="store_true")
-    parser.add_argument("-A", "--use-apm", help="Send APM spans to SIM", action="store_true")
     args = parser.parse_args()
 
     sys.exit(
@@ -270,6 +258,5 @@ if __name__ == "__main__":
             only_translate=args.only_translate,
             skip_movie=args.skip_movie,
             science_workflow_name=args.workflow_name,
-            use_apm=args.use_apm,
         )
     )

dkist_processing_vbi/tests/test_assemble_movie.py

@@ -2,14 +2,13 @@ import numpy as np
 import pytest
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 from dkist_processing_vbi.models.tags import VbiTag
 from dkist_processing_vbi.tasks.assemble_movie import AssembleVbiMovie
-from dkist_processing_vbi.tests.conftest import generate_214_l1_fits_frame
 from dkist_processing_vbi.tests.conftest import Vbi122ObserveFrames
 from dkist_processing_vbi.tests.conftest import VbiConstantsDb
 from dkist_processing_vbi.tests.conftest import VbiInputDatasetParameterValues
+from dkist_processing_vbi.tests.conftest import generate_214_l1_fits_frame
 
 
 @pytest.fixture(scope="function")
@@ -49,10 +48,13 @@ def assemble_task_with_tagged_movie_frames(tmp_path, recipe_run_id, init_vbi_con
 
 
 def test_assemble_movie(
-    assemble_task_with_tagged_movie_frames, mocker, assign_input_dataset_doc_to_task
+    assemble_task_with_tagged_movie_frames,
+    mocker,
+    assign_input_dataset_doc_to_task,
+    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 = assemble_task_with_tagged_movie_frames
     assign_input_dataset_doc_to_task(task, VbiInputDatasetParameterValues())

dkist_processing_vbi/tests/test_dark.py

@@ -7,13 +7,12 @@ from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.fits import fits_array_decoder
 from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.models.tags import Tag
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 from dkist_processing_vbi.models.tags import VbiTag
 from dkist_processing_vbi.tasks.dark import DarkCalibration
-from dkist_processing_vbi.tests.conftest import ensure_all_inputs_used
 from dkist_processing_vbi.tests.conftest import Vbi122DarkFrames
 from dkist_processing_vbi.tests.conftest import VbiConstantsDb
+from dkist_processing_vbi.tests.conftest import ensure_all_inputs_used
 
 
 @pytest.fixture(scope="function")
@@ -65,14 +64,14 @@ def dark_calibration_task(tmp_path, recipe_run_id, init_vbi_constants_db):
         task._purge()
 
 
-def test_dark_calibration_task(dark_calibration_task, mocker):
+def test_dark_calibration_task(dark_calibration_task, mocker, fake_gql_client):
     """
     Given: a set of parsed input dark frames and a DarkCalibration task
     When: running the task
     Then: a single output array is produced for each spatial step and the array values are correct
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     dark_calibration_task()
 

dkist_processing_vbi/tests/test_gain.py

@@ -7,14 +7,13 @@ from dkist_processing_common.codecs.fits import fits_array_decoder
 from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_processing_common.models.tags import Tag
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 from dkist_processing_vbi.models.tags import VbiTag
 from dkist_processing_vbi.tasks.gain import GainCalibration
-from dkist_processing_vbi.tests.conftest import ensure_all_inputs_used
-from dkist_processing_vbi.tests.conftest import generate_214_l0_fits_frame
 from dkist_processing_vbi.tests.conftest import Vbi122GainFrames
 from dkist_processing_vbi.tests.conftest import VbiConstantsDb
+from dkist_processing_vbi.tests.conftest import ensure_all_inputs_used
+from dkist_processing_vbi.tests.conftest import generate_214_l0_fits_frame
 
 
 @pytest.fixture(scope="function")
@@ -65,14 +64,14 @@ def gain_calibration_task(tmp_path, recipe_run_id, init_vbi_constants_db):
         task._purge()
 
 
-def test_gain_calibration(gain_calibration_task, mocker):
+def test_gain_calibration(gain_calibration_task, mocker, fake_gql_client):
     """
     Given: a set of parsed input gain frames, dark calibration frames, and a GainCalibration task
     When: the task is run
     Then: a single array is produced for each step and the array values are correctly normalized
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     gain_calibration_task()
 

dkist_processing_vbi/tests/test_make_movie_frames.py

@@ -9,16 +9,15 @@ from dkist_processing_common.codecs.fits import fits_access_decoder
 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.fits_access import FitsAccessBase
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 from dkist_processing_vbi.models.constants import VbiConstants
 from dkist_processing_vbi.models.tags import VbiTag
 from dkist_processing_vbi.parsers.vbi_l1_fits_access import VbiL1FitsAccess
 from dkist_processing_vbi.tasks.make_movie_frames import MakeVbiMovieFrames
-from dkist_processing_vbi.tests.conftest import ensure_all_inputs_used
-from dkist_processing_vbi.tests.conftest import generate_214_l1_fits_frame
 from dkist_processing_vbi.tests.conftest import Vbi122ObserveFrames
 from dkist_processing_vbi.tests.conftest import VbiConstantsDb
+from dkist_processing_vbi.tests.conftest import ensure_all_inputs_used
+from dkist_processing_vbi.tests.conftest import generate_214_l1_fits_frame
 
 
 @pytest.fixture(scope="function")
@@ -178,9 +177,9 @@ def compute_expected_mosiac(modification: int):
     return expected
 
 
-def test_make_movie_frames_task(raw_make_movie_frames_task, mocker):
+def test_make_movie_frames_task(raw_make_movie_frames_task, 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
     )
 
     raw_make_movie_frames_task()