dkist-processing-common 11.7.0rc6__py3-none-any.whl → 11.9.3__py3-none-any.whl

dkist_processing_common/tasks/parse_l0_input_data.py

@@ -37,6 +37,7 @@ from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.parsers.average_bud import TaskAverageBud
 from dkist_processing_common.parsers.experiment_id_bud import ContributingExperimentIdsBud
 from dkist_processing_common.parsers.experiment_id_bud import ExperimentIdBud
+from dkist_processing_common.parsers.lookup_bud import TaskTimeLookupBud
 from dkist_processing_common.parsers.observing_program_id_bud import (
     TaskContributingObservingProgramExecutionIdsBud,
 )
@@ -103,6 +104,12 @@ def dataset_extra_bud_factory() -> list[S]:
             constant_name=BudName.polcal_observing_program_execution_ids,
             ip_task_types=TaskName.polcal,
         ),
+        TaskTimeLookupBud(
+            constant_name=BudName.dark_num_raw_frames_per_fpa,
+            key_metadata_key=MetadataKey.sensor_readout_exposure_time_ms,
+            value_metadata_key=MetadataKey.num_raw_frames_per_fpa,
+            ip_task_types=TaskName.dark,
+        ),
         TaskUniqueBud(
             constant_name=BudName.solar_gain_num_raw_frames_per_fpa,
             metadata_key=MetadataKey.num_raw_frames_per_fpa,

dkist_processing_common/tasks/trial_catalog.py

@@ -5,15 +5,18 @@ import logging
 from datetime import datetime
 from itertools import chain
 from pathlib import Path
+from typing import Any
 from typing import Generator
 from uuid import uuid4
 
 from dkist_processing_common.codecs.asdf import asdf_fileobj_encoder
+from dkist_processing_common.codecs.basemodel import basemodel_decoder
 from dkist_processing_common.codecs.fits import fits_access_decoder
 from dkist_processing_common.codecs.json import json_encoder
 from dkist_processing_common.codecs.path import path_decoder
 from dkist_processing_common.codecs.quality import quality_data_decoder
 from dkist_processing_common.models.fits_access import FitsAccessBase
+from dkist_processing_common.models.input_dataset import InputDatasetPartDocumentList
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks.output_data_base import OutputDataBase
 
@@ -27,6 +30,7 @@ INVENTORY_EXTRA_INSTALLED = False
 try:
     from dkist_inventory.inventory import generate_asdf_filename
     from dkist_inventory.inventory import generate_inventory_from_frame_inventory
+    from dkist_inventory.inventory import generate_quality_report_filename
 
     INVENTORY_EXTRA_INSTALLED = True
 except ModuleNotFoundError:
@@ -138,11 +142,15 @@ class CreateTrialAsdf(OutputDataBase):
 
     def run(self) -> None:
         """Generate an ASDF file simulating the ASDF file that would be produced when cataloging the dataset."""
+        with self.telemetry_span("Collate input dataset parameters"):
+            parameters = self.parse_input_dataset_parameters()
+
         with self.telemetry_span("Generate ASDF tree"):
             tree = asdf_tree_from_filenames(
                 filenames=self.absolute_output_frame_paths,
                 hdu=1,  # compressed
                 relative_to=self.scratch.workflow_base_path,
+                parameters=parameters,
             )
 
         trial_history = [
@@ -169,6 +177,37 @@ class CreateTrialAsdf(OutputDataBase):
                     ),
                 )
 
+    def parse_input_dataset_parameters(self) -> list[dict[str, Any]]:
+        """
+        Return the parameters associated with the dataset.
+
+        Returns
+        -------
+        list[dict[str, Any]]
+            A list of dictionaries, each containing a parameter name and its values.
+
+        Raises
+        ------
+        ValueError
+            If there is not exactly one ``InputDatasetPartDocumentList`` found.
+        """
+        part_docs_iter = self.read(
+            tags=Tag.input_dataset_parameters(),
+            decoder=basemodel_decoder,
+            model=InputDatasetPartDocumentList,
+        )
+        docs = list(part_docs_iter)
+
+        if not docs:
+            logger.warning("No parameter list decoded from files")
+            return []
+
+        if len(docs) > 1:
+            raise ValueError(f"Expected 1 parameter list, found {len(docs)}")
+
+        parameters = docs[0].model_dump(by_alias=True).get("doc_list", [])
+        return parameters
+
 
 class CreateTrialQualityReport(OutputDataBase):
     """
@@ -186,6 +225,13 @@ class CreateTrialQualityReport(OutputDataBase):
                 f" but the required dependencies were not found."
             )
 
+        if not INVENTORY_EXTRA_INSTALLED:
+            raise ModuleNotFoundError(
+                f"{self.__class__.__name__} Task requires the dkist-inventory package "
+                f"(e.g. via an 'inventory' pip_extra on dkist_processing_core.Workflow().add_node())"
+                f" but the required dependencies were not found."
+            )
+
     def run(self) -> None:
         """Generate the quality report for the dataset."""
         self.create_trial_quality_report()
@@ -207,5 +253,7 @@ class CreateTrialQualityReport(OutputDataBase):
             self.write(
                 quality_report,
                 tags=[Tag.output(), Tag.quality_report()],
-                relative_path=f"{self.constants.dataset_id}_quality_report.pdf",
+                relative_path=generate_quality_report_filename(
+                    dataset_id=self.constants.dataset_id
+                ),
             )

dkist_processing_common/tasks/trial_output_data.py

@@ -100,7 +100,7 @@ class TransferTrialData(TransferDataBase, GlobusMixin):
         tag_list = []
         tag_list += [[Tag.output(), Tag.dataset_inventory()]]
         tag_list += [[Tag.output(), Tag.asdf()]]
-        tag_list += [[Tag.quality_data()]]  # quality data is not tagged as OUTPUT
+        tag_list += [[Tag.output(), Tag.quality_data()]]
         tag_list += [[Tag.output(), Tag.quality_report()]]
         tag_list += [[Tag.output(), Tag.movie()]]
         return tag_list

dkist_processing_common/tests/mock_metadata_store.py

@@ -6,6 +6,7 @@ import json
 from abc import ABC
 from abc import abstractmethod
 from datetime import datetime
+from datetime import timedelta
 from pathlib import Path
 from uuid import uuid4
 
@@ -134,10 +135,6 @@ class InputDatasetRecipeRunResponseMapping(ResponseMapping):
         return Unset
 
 
-class QualityResponseMapping(ResponseMapping):
-    pass  # TODO
-
-
 def make_default_recipe_run_status_response() -> RecipeRunStatusResponse:
     return RecipeRunStatusResponse(recipeRunStatusId=1)
 
@@ -234,3 +231,41 @@ def fake_gql_client():
     Convenience fixture for default mock GQL client. To customize, use fake_gql_client_factory.
     """
     return fake_gql_client_factory()
+
+
+def input_dataset_parameters_part_factory(
+    parameter_count: int = 1,
+    parameter_value_count: int = 1,
+    has_date: bool = False,
+    has_file: bool = False,
+) -> list[dict]:
+    """Create a mock InputDatasetPartDocumentList with parameters."""
+    result = [
+        {
+            "parameterName": uuid4().hex[:6],
+            "parameterValues": [
+                {"parameterValueId": i, "parameterValue": json.dumps(uuid4().hex)}
+                for i in range(parameter_value_count)
+            ],
+        }
+        for _ in range(parameter_count)
+    ]
+    if has_date:
+        base = datetime(2018, 9, 14, 0, 0, 0)  # This date is before any possible start dates
+        for parameter_index, data in enumerate(result):
+            for item in data["parameterValues"]:
+                dt = base + timedelta(days=parameter_index)
+                item["parameterValueStartDate"] = dt.isoformat()
+    if has_file:
+        for data in result:
+            param_list = data["parameterValues"]
+            for item in param_list:
+                item["parameterValue"] = json.dumps(
+                    {
+                        "__file__": {
+                            "bucket": "data",
+                            "objectKey": f"parameters/{data['parameterName']}/{uuid4().hex}.dat",
+                        }
+                    }
+                )
+    return result

dkist_processing_common/tests/test_input_dataset.py

@@ -1,5 +1,4 @@
 import json
-from datetime import datetime
 from typing import Any
 from uuid import uuid4
 
@@ -8,6 +7,7 @@ import pytest
 from dkist_processing_common.codecs.basemodel import basemodel_decoder
 from dkist_processing_common.models.input_dataset import InputDatasetPartDocumentList
 from dkist_processing_common.models.tags import Tag
+from dkist_processing_common.tests.mock_metadata_store import input_dataset_parameters_part_factory
 
 
 def input_dataset_frames_part_factory(bucket_count: int = 1) -> list[dict]:
@@ -25,42 +25,6 @@ def flatten_frame_parts(frame_parts: list[dict]) -> list[tuple[str, str]]:
     return result
 
 
-def input_dataset_parameters_part_factory(
-    parameter_count: int = 1,
-    parameter_value_count: int = 1,
-    has_date: bool = False,
-    has_file: bool = False,
-) -> list[dict]:
-    result = [
-        {
-            "parameterName": uuid4().hex[:6],
-            "parameterValues": [
-                {"parameterValueId": i, "parameterValue": json.dumps(uuid4().hex)}
-                for i in range(parameter_value_count)
-            ],
-        }
-        for _ in range(parameter_count)
-    ]
-    if has_date:
-        for data in result:
-            param_list = data["parameterValues"]
-            for item in param_list:
-                item["parameterValueStartDate"] = datetime(2022, 9, 14).isoformat()
-    if has_file:
-        for data in result:
-            param_list = data["parameterValues"]
-            for item in param_list:
-                item["parameterValue"] = json.dumps(
-                    {
-                        "__file__": {
-                            "bucket": "data",
-                            "objectKey": f"parameters/{data['parameterName']}/{uuid4().hex}.dat",
-                        }
-                    }
-                )
-    return result
-
-
 @pytest.mark.parametrize(
     "input_dataset_parts",
     [

dkist_processing_common/tests/test_parse_l0_input_data.py

@@ -17,6 +17,7 @@ from dkist_processing_common.models.flower_pot import Stem
 from dkist_processing_common.models.flower_pot import Thorn
 from dkist_processing_common.models.tags import StemName
 from dkist_processing_common.models.tags import Tag
+from dkist_processing_common.parsers.lookup_bud import TimeLookupBud
 from dkist_processing_common.parsers.single_value_single_key_flower import (
     SingleValueSingleKeyFlower,
 )
@@ -117,6 +118,17 @@ def visp_buds():
     return [UniqueBud(constant_name=BudName.num_modstates, metadata_key=ViSPMetadataKey.num_mod)]
 
 
+@pytest.fixture(scope="function")
+def visp_lookup_buds():
+    return [
+        TimeLookupBud(
+            constant_name="LOOKUP_BUD",
+            key_metadata_key=ViSPMetadataKey.num_mod,
+            value_metadata_key=ViSPMetadataKey.modstate,
+        )
+    ]
+
+
 @pytest.fixture(scope="function")
 def empty_flowers():
     class EmptyFlower(Stem):
@@ -161,8 +173,17 @@ def picky_buds():
 
 @pytest.fixture(scope="function")
 def parse_inputs_task(
-    tmp_path, visp_flowers, visp_buds, empty_flowers, empty_buds, picky_buds, recipe_run_id
+    tmp_path,
+    visp_flowers,
+    visp_buds,
+    visp_lookup_buds,
+    empty_flowers,
+    empty_buds,
+    picky_buds,
+    recipe_run_id,
 ):
+    """Override parse task class and make data for testing."""
+
     class TaskClass(ParseL0InputDataBase):
         @property
         def tag_flowers(self):
@@ -170,7 +191,7 @@ def parse_inputs_task(
 
         @property
         def constant_buds(self):
-            return visp_buds + empty_buds + picky_buds
+            return visp_buds + visp_lookup_buds + empty_buds + picky_buds
 
         @property
         def fits_parsing_class(self):
@@ -210,6 +231,8 @@ def parse_inputs_task(
 
 @pytest.fixture()
 def visp_parse_inputs_task(tmp_path, visp_flowers, visp_buds, recipe_run_id):
+    """Extend parse task class, but don't make data for testing."""
+
     class TaskClass(ParseL0InputDataBase):
         @property
         def tag_flowers(self):
@@ -243,12 +266,13 @@ def test_make_flowerpots(parse_inputs_task):
     tag_pot, constant_pot = parse_inputs_task.make_flower_pots()
 
     assert len(tag_pot.stems) == 2
-    assert len(constant_pot.stems) == 3
+    assert len(constant_pot.stems) == 4
     assert tag_pot.stems[0].stem_name == StemName.modstate
     assert tag_pot.stems[1].stem_name == "EMPTY_FLOWER"
     assert constant_pot.stems[0].stem_name == BudName.num_modstates
-    assert constant_pot.stems[1].stem_name == "EMPTY_BUD"
-    assert constant_pot.stems[2].stem_name == "PICKY_BUD"
+    assert constant_pot.stems[1].stem_name == "LOOKUP_BUD"
+    assert constant_pot.stems[2].stem_name == "EMPTY_BUD"
+    assert constant_pot.stems[3].stem_name == "PICKY_BUD"
 
 
 def test_subclass_flowers(visp_parse_inputs_task, max_cs_step_time_sec):
@@ -260,7 +284,7 @@ def test_subclass_flowers(visp_parse_inputs_task, max_cs_step_time_sec):
     tag_pot, constant_pot = visp_parse_inputs_task.make_flower_pots()
 
     assert len(tag_pot.stems) == 1
-    assert len(constant_pot.stems) == 60
+    assert len(constant_pot.stems) == 61
     all_flower_names = [StemName.modstate]
     assert sorted([f.stem_name for f in tag_pot.stems]) == sorted(all_flower_names)
     all_bud_names = [b.stem_name for b in default_constant_bud_factory()] + [BudName.num_modstates]
@@ -296,27 +320,23 @@ def test_dataset_extra_bud_factory(visp_parse_inputs_task, max_cs_step_time_sec)
     ]
     for base in bud_name_base:
         assert "SOLAR_GAIN_" + base in stem_names
-        if base not in [
-            "NUM_RAW_FRAMES_PER_FPA",
-            "TELESCOPE_TRACKING_MODE",
-            "COUDE_TABLE_TRACKING_MODE",
-            "TELESCOPE_SCANNING_MODE",
-        ]:
-            assert "DARK_" + base in stem_names
-        if "GOS" not in base:
-            assert "POLCAL_" + base in stem_names
+        # telescope mode keys are not constant for dark frames
+        assert ("DARK_" + base in stem_names) ^ ("MODE" in base)
+        # gos keys are not constant for polcal frames
+        assert ("POLCAL_" + base in stem_names) ^ ("GOS" in base)
 
 
 def test_constants_correct(parse_inputs_task):
     """
     Given: ParseInputData task with a populated constant FlowerPot
     When: Updating pipeline constants
-    Then: A pipeline constant is correctly populated
+    Then: A pipeline constant is correctly populated and the values return correctly
     """
     _, constant_pot = parse_inputs_task.make_flower_pots()
     parse_inputs_task.update_constants(constant_pot)
     assert dict(parse_inputs_task.constants._db_dict) == {
         BudName.num_modstates.value: parse_inputs_task._num_mod,
+        "LOOKUP_BUD": [[parse_inputs_task._num_mod, [0, 1]]],
     }
 
 

dkist_processing_common/tests/test_publish_catalog_messages.py

@@ -57,24 +57,3 @@ def test_object_messages(publish_catalog_and_quality_messages_task):
         assert message.body.conversationId == str(task.recipe_run_id)
         assert message.body.objectType == object_type
         assert message.body.groupId == task.constants.dataset_id
-
-
-def test_quality_report_message(publish_catalog_and_quality_messages_task):
-    """
-    :Given: a PublishCatalogAndQualityMessages task
-    :When: creating quality report message
-    :Then: the attributes are correctly populated
-    """
-    # Given
-    task, proposal_id = publish_catalog_and_quality_messages_task
-    # When
-    message = task.quality_report_message
-    # Then
-    assert isinstance(message, CreateQualityReportMessage)
-    assert message.body.bucket == task.destination_bucket
-    # objectName exists and can be evaluated as a valid path
-    assert message.body.objectName
-    _ = Path(message.body.objectName)
-    assert message.body.datasetId == task.constants.dataset_id
-    assert message.body.conversationId == str(task.recipe_run_id)
-    assert message.body.incrementDatasetCatalogReceiptCount is True

dkist_processing_common/tests/test_quality_mixin.py

@@ -1214,12 +1214,20 @@ def wavecal_weights(wavecal_input_wavelength) -> np.ndarray:
 
 
 @pytest.fixture(scope="session")
-def wavecal_fit_result(wavecal_input_wavelength) -> FitResult:
+def wavecal_fit_result(wavecal_input_wavelength, wavecal_input_spectrum) -> FitResult:
     wavelength_params = WavelengthParameters(
         crpix=1, crval=10.0, dispersion=1, grating_constant=1, order=1, incident_light_angle=0
     )
-    minimizer_result = MinimizerResult(residual=np.random.random(wavecal_input_wavelength.size))
-    return FitResult(wavelength_parameters=wavelength_params, minimizer_result=minimizer_result)
+
+    residuals = np.random.random(wavecal_input_wavelength.size)
+    residuals[-1] = np.nan
+    minimizer_result = MinimizerResult(residual=residuals)
+    return FitResult(
+        wavelength_parameters=wavelength_params,
+        minimizer_result=minimizer_result,
+        input_wavelength_vector=wavecal_input_wavelength,
+        input_spectrum=wavecal_input_spectrum,
+    )
 
 
 @pytest.mark.parametrize(

dkist_processing_common/tests/test_stems.py

@@ -1,3 +1,4 @@
+import collections
 from enum import StrEnum
 from itertools import chain
 
@@ -17,6 +18,8 @@ from dkist_processing_common.parsers.dsps_repeat import TotalDspsRepeatsBud
 from dkist_processing_common.parsers.experiment_id_bud import ContributingExperimentIdsBud
 from dkist_processing_common.parsers.experiment_id_bud import ExperimentIdBud
 from dkist_processing_common.parsers.id_bud import TaskContributingIdsBud
+from dkist_processing_common.parsers.lookup_bud import TaskTimeLookupBud
+from dkist_processing_common.parsers.lookup_bud import TimeLookupBud
 from dkist_processing_common.parsers.near_bud import NearFloatBud
 from dkist_processing_common.parsers.near_bud import TaskNearFloatBud
 from dkist_processing_common.parsers.observing_program_id_bud import (
@@ -203,7 +206,7 @@ def basic_header_objs():
                 "ID___012": "experiment_id_1",
                 "XPOSURE": 100.0,
                 "TEXPOSUR": 11.0,
-                "NSUMEXP": 4,
+                "NSUMEXP": 5,
                 "DSPSNUM": 2,
                 "DSPSREPS": 2,
                 "DATE-OBS": "2022-06-17T22:00:03.000",
@@ -1087,4 +1090,49 @@ def test_task_average_bud(basic_header_objs):
     assert round(petal[0].value, 3) == 1.227
 
 
+def test_time_lookup_bud(basic_header_objs):
+    """
+    Given: A set of headers with two differently valued header keys
+    When: Ingesting headers with a TimeLookupBud and asking for the value
+    Then: The bud's value is a dictionary of one key to sets of the other key as nested tuples
+    """
+    bud = TimeLookupBud(
+        constant_name="lookup",
+        key_metadata_key=FitsReaderMetadataKey.fpa_exposure_time_ms,
+        value_metadata_key=FitsReaderMetadataKey.num_raw_frames_per_fpa,
+    )
+    assert bud.stem_name == "lookup"
+    for fo in basic_header_objs:
+        key = fo.name
+        bud.update(key, fo)
+
+    assert type(bud.mapping) == collections.defaultdict
+    assert bud.mapping == {0.0013: {3}, 12.345: {1}, 100.0: {4, 5}}
+    assert len(bud.petals) == 1
+    expected_value = ((0.0013, (3,)), (12.345, (1,)), (100.0, (4, 5)))
+    assert bud.petals[0].value == expected_value
+
+
+def test_task_time_lookup_bud(basic_header_objs):
+    """
+    Given: A set of headers with two differently valued header keys
+    When: Ingesting headers with a TaskTimeLookupBud and asking for the value
+    Then: The bud's value is a dictionary of one key to sets of the other key as nested tuples
+    """
+    bud = TaskTimeLookupBud(
+        constant_name="task_lookup",
+        key_metadata_key=FitsReaderMetadataKey.fpa_exposure_time_ms,
+        value_metadata_key=FitsReaderMetadataKey.num_raw_frames_per_fpa,
+        ip_task_types="dark",
+    )
+    assert bud.stem_name == "task_lookup"
+    for fo in basic_header_objs:
+        key = fo.name
+        bud.update(key, fo)
+
+    assert len(bud.petals) == 1
+    expected_value = ((12.345, (1,)),)
+    assert bud.petals[0].value == expected_value
+
+
 # TODO: test new stem types that have been added to parse_l0_input_data

dkist_processing_common/tests/test_submit_dataset_metadata.py

@@ -95,13 +95,10 @@ def test_submit_dataset_metadata(
     mocker.patch(
         "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
-    # intercept these two GraphQLClient calls so they can be confirmed
+    # intercept this GraphQLClient call so it can be confirmed
     mocked_metadata_store_add_dataset_receipt_account = mocker.patch.object(
         metadata_store.MetadataStoreMixin, "metadata_store_add_dataset_receipt_account"
     )
-    mocked_metadata_store_add_quality_data = mocker.patch.object(
-        metadata_store.MetadataStoreMixin, "metadata_store_add_quality_data"
-    )
     task = submit_dataset_metadata_task
 
     # When
@@ -109,4 +106,3 @@ def test_submit_dataset_metadata(
 
     # Then
     mocked_metadata_store_add_dataset_receipt_account.assert_called_once()
-    mocked_metadata_store_add_quality_data.assert_called_once()

dkist_processing_common/tests/test_trial_catalog.py

@@ -12,14 +12,30 @@ from sqids import Sqids
 
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.asdf import asdf_decoder
+from dkist_processing_common.codecs.basemodel import basemodel_encoder
 from dkist_processing_common.codecs.bytes import bytes_decoder
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_processing_common.codecs.json import json_decoder
 from dkist_processing_common.codecs.quality import quality_data_encoder
+from dkist_processing_common.models.input_dataset import InputDatasetParameter
+from dkist_processing_common.models.input_dataset import InputDatasetPartDocumentList
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks import CreateTrialAsdf
 from dkist_processing_common.tasks import CreateTrialDatasetInventory
 from dkist_processing_common.tasks import CreateTrialQualityReport
+from dkist_processing_common.tests.mock_metadata_store import input_dataset_parameters_part_factory
+
+
+@pytest.fixture()
+def mock_input_dataset_parts() -> InputDatasetPartDocumentList:
+    """An InputDatasetPartDocumentList with two parameters, each with one value and a date."""
+    raw = input_dataset_parameters_part_factory(
+        parameter_count=2,
+        parameter_value_count=1,
+        has_date=True,
+        has_file=False,
+    )
+    return InputDatasetPartDocumentList.model_validate({"doc_list": raw})
 
 
 @pytest.fixture()
@@ -41,6 +57,24 @@ def scratch_with_l1_frames(recipe_run_id, tmp_path) -> WorkflowFileSystem:
         scratch.write(
             file_obj, tags=[Tag.output(), Tag.frame()], relative_path=f"{uuid4().hex}.dat"
         )
+
+    return scratch
+
+
+@pytest.fixture()
+def scratch_with_l1_frames_and_parameters(
+    scratch_with_l1_frames, mock_input_dataset_parts
+) -> WorkflowFileSystem:
+    """Scratch instance for a recipe run id with tagged L1 frames and input parameters."""
+    scratch = scratch_with_l1_frames
+
+    # Write validated Pydantic model bytes expected by InputDatasetPartDocumentList
+    file_obj = basemodel_encoder(mock_input_dataset_parts)
+    scratch.write(
+        file_obj,
+        tags=Tag.input_dataset_parameters(),
+        relative_path=f"{uuid4().hex}.json",
+    )
     return scratch
 
 
@@ -85,6 +119,22 @@ def create_trial_asdf_task(
     task._purge()
 
 
+@pytest.fixture(scope="function")
+def create_trial_asdf_task_with_params(
+    recipe_run_id, tmp_path, scratch_with_l1_frames_and_parameters, fake_constants_db
+) -> CreateTrialAsdf:
+    """An instance of CreateTrialAsdf with L1 frames and input parameters tagged in scratch."""
+    task = CreateTrialAsdf(
+        recipe_run_id=recipe_run_id,
+        workflow_name="trial_asdf",
+        workflow_version="trial_asdf_version",
+    )
+    task.scratch = scratch_with_l1_frames_and_parameters
+    task.constants._update(fake_constants_db)
+    yield task
+    task._purge()
+
+
 @pytest.fixture()
 def create_trial_quality_report_task(
     recipe_run_id, tmp_path, fake_constants_db
@@ -143,25 +193,32 @@ def test_create_trial_dataset_inventory(create_trial_dataset_inventory_task):
     assert len(inventory) > 20  # a bunch
 
 
-def test_create_trial_asdf(create_trial_asdf_task, recipe_run_id):
+@pytest.mark.parametrize("with_params", [False, True], ids=["no_params", "with_params"])
+def test_create_trial_asdf(with_params, request, recipe_run_id, mock_input_dataset_parts):
     """
     :Given: An instance of CreateTrialAsdf with L1 frames tagged in scratch
     :When: CreateTrialAsdf is run
     :Then: An asdf file for the dataset is tagged in scratch
     """
-    task = create_trial_asdf_task
+    task = request.getfixturevalue(
+        "create_trial_asdf_task_with_params" if with_params else "create_trial_asdf_task"
+    )
     # When
     task()
+
     # Then
     asdf_tags = [Tag.output(), Tag.asdf()]
     filepaths = list(task.scratch.find_all(tags=asdf_tags))
     assert len(filepaths) == 1
     dataset_id = Sqids(min_length=6, alphabet=ascii_uppercase).encode([recipe_run_id])
     assert filepaths[0].name == f"INSTRUMENT_L1_20240416T160000_{dataset_id}_metadata.asdf"
+
     results = list(task.read(tags=asdf_tags, decoder=asdf_decoder))
     assert len(results) == 1
+
     tree = results[0]
     assert isinstance(tree, dict)
+
     for file_name in tree["dataset"].files.filenames:
         # This is a slightly better than check that `not Path(file_name).is_absolute()` because it confirms
         # we've correctly stripped the path of *all* parents (not just those that start at root).
@@ -169,6 +226,19 @@ def test_create_trial_asdf(create_trial_asdf_task, recipe_run_id):
         # `scratch.workflow_base_path`
         assert Path(file_name).name == file_name
 
+    # Only check parameters when present
+    ds = tree["dataset"]
+    assert "parameters" in ds.meta
+    parameters = ds.meta["parameters"]
+    assert isinstance(parameters, list)
+    if with_params:
+        assert parameters, f"ASDF tree must include input parameters: {parameters}"
+        assert len(parameters) == len(mock_input_dataset_parts.doc_list)
+        for param in parameters:
+            assert InputDatasetParameter.model_validate(param) in mock_input_dataset_parts.doc_list
+    else:
+        assert ds.meta["parameters"] == []
+
 
 def test_create_trial_quality_report(create_trial_quality_report_task):
     """

dkist_processing_common/tests/test_trial_output_data.py

@@ -158,13 +158,12 @@ def complete_trial_output_task(
         task.write(asdf_file_obj, relative_path=asdf_file_name, tags=[Tag.output(), Tag.asdf()])
 
         # Write quality data
-        # quality data is not tagged as OUTPUT
         quality_data_obj = uuid4().hex.encode("utf8")
         quality_data_name = "quality_data.json"
         task.write(
             quality_data_obj,
             relative_path=quality_data_name,
-            tags=Tag.quality_data(),
+            tags=[Tag.output(), Tag.quality_data()],
         )
 
         # Write a quality report file