dkist-processing-vbi 1.22.0__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
 

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,4 +1,5 @@
 """VBI-specific assemble movie task subclass."""
+
 from typing import Type
 
 import numpy as np

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 (

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,4 +1,5 @@
 """VBI base task."""
+
 from abc import ABC
 
 from dkist_processing_common.tasks import WorkflowTaskBase

dkist_processing_vbi/tasks/write_l1.py

@@ -1,4 +1,5 @@
 """VBI Write L1 task."""
+
 from typing import Literal
 from typing import Type
 
@@ -13,8 +14,8 @@ 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 find_associated_filter
 from dkist_processing_vbi.models.filter import VBI_FILTERS
+from dkist_processing_vbi.models.filter import find_associated_filter
 
 __all__ = ["VbiWriteL1Frame"]
 

dkist_processing_vbi/tests/conftest.py

@@ -16,6 +16,7 @@ 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
@@ -95,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:
@@ -122,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):

dkist_processing_vbi/tests/local_trial_workflows/l0_to_l1.py

@@ -146,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)
@@ -181,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,
@@ -265,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(
@@ -277,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()

dkist_processing_vbi/tests/test_parse_l0.py

@@ -4,15 +4,14 @@ import pytest
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_processing_common.models.constants import BudName
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 from dkist_processing_vbi.models.constants import VbiBudName
 from dkist_processing_vbi.models.tags import VbiTag
 from dkist_processing_vbi.tasks.parse import ParseL0VbiInputData
-from dkist_processing_vbi.tests.conftest import generate_214_l0_fits_frame
 from dkist_processing_vbi.tests.conftest import Vbi122DarkFrames
 from dkist_processing_vbi.tests.conftest import Vbi122GainFrames
 from dkist_processing_vbi.tests.conftest import Vbi122ObserveFrames
+from dkist_processing_vbi.tests.conftest import generate_214_l0_fits_frame
 
 
 @pytest.fixture(scope="function")
@@ -181,14 +180,14 @@ def parse_inputs_task_with_aborted_last_mosaic(tmp_path, recipe_run_id):
         task._purge()
 
 
-def test_parse_l0_input_data_spatial_pos(parse_inputs_task, mocker):
+def test_parse_l0_input_data_spatial_pos(parse_inputs_task, mocker, fake_gql_client):
     """
     Given: a set of raw inputs of multiple task types and a ParseL0VbiInputData task
     When: the task is run
     Then: the input frames are correctly tagged by spatial position
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     parse_inputs_task()
 
@@ -208,14 +207,14 @@ def test_parse_l0_input_data_spatial_pos(parse_inputs_task, mocker):
             assert filepath.exists()
 
 
-def test_parse_l0_input_constants(parse_inputs_task, mocker):
+def test_parse_l0_input_constants(parse_inputs_task, mocker, fake_gql_client):
     """
     Given: a set of raw inputs of multiple task types and a ParseL0VbiInputData task
     When: the task is run
     Then: pipeline constants are correctly updated from the input headers
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     parse_inputs_task()
 
@@ -231,14 +230,14 @@ def test_parse_l0_input_constants(parse_inputs_task, mocker):
     assert BudName.obs_ip_start_time.value in parse_inputs_task.constants._db_dict
 
 
-def test_parse_l0_input_frames_found(parse_inputs_task, mocker):
+def test_parse_l0_input_frames_found(parse_inputs_task, mocker, fake_gql_client):
     """
     Given: a set of raw inputs of multiple task types and a ParseL0VbiInputData task
     When: the task is run
     Then: the frames from each task type are correctly identified and tagged
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     parse_inputs_task()
     assert (
@@ -258,7 +257,9 @@ def test_parse_l0_input_frames_found(parse_inputs_task, mocker):
     )
 
 
-def test_parse_l0_input_with_only_observe(parse_inputs_task_with_only_observe, mocker):
+def test_parse_l0_input_with_only_observe(
+    parse_inputs_task_with_only_observe, mocker, fake_gql_client
+):
     """
     Given: a set of raw inputs of a single task type and a ParseL0VbiInputData task
     When: the task is run
@@ -266,7 +267,7 @@ def test_parse_l0_input_with_only_observe(parse_inputs_task_with_only_observe, m
     """
     task, camera_str = parse_inputs_task_with_only_observe
     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()
     if camera_str == "red":
@@ -293,14 +294,16 @@ def test_parse_l0_input_with_only_observe(parse_inputs_task_with_only_observe, m
                 assert filepath.exists()
 
 
-def test_parse_l0_aborted_last_mosaic(parse_inputs_task_with_aborted_last_mosaic, mocker):
+def test_parse_l0_aborted_last_mosaic(
+    parse_inputs_task_with_aborted_last_mosaic, mocker, fake_gql_client
+):
     """
     Given: a set of raw inputs representing a dataset with an aborted last mosaic
     When: the task is run
     Then: pipeline constants are correctly updated from the input headers
     """
     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, expected_num_mosaic_repeats = parse_inputs_task_with_aborted_last_mosaic
     task()
@@ -310,14 +313,16 @@ def test_parse_l0_aborted_last_mosaic(parse_inputs_task_with_aborted_last_mosaic
     )
 
 
-def test_parse_l0_correctly_tagged_mosaic_subrepeats(parse_inputs_task_with_subrepeats, mocker):
+def test_parse_l0_correctly_tagged_mosaic_subrepeats(
+    parse_inputs_task_with_subrepeats, mocker, fake_gql_client
+):
     """
     Given: A set of observe frames taken with subrepeats (i.e., multiple mosaics per DSPS repeat)
     When: the parse task is run
     Then: pipeline constants are correctly updated and the 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
     )
     task = parse_inputs_task_with_subrepeats
     task()